// This file was generated at Thu, 07 Mar 2013 07:22:02 +0000 with gle, please do not modify.

// GLE - Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, Nicolas Papier.
// Distributed under the terms of the GNU Library General Public License (LGPL)
// as published by the Free Software Foundation.
// Author Nicolas Papier

// This file was generated using :
// /* glext.h last updated $Date: 2013-02-07 01:42:49 -0800 (Thu, 07 Feb 2013) $ */
// #define GL_GLEXT_VERSION 86
// /* glxext.h last updated 2013/01/02 */
// #define GLX_GLXEXT_VERSION 34
// /* wglext.h last updated 2012/01/04 */
// #define WGL_WGLEXT_VERSION 24

#include "gle/OpenGLExtensionsGen.hpp"

#include <algorithm>
#include <functional>
#include <iterator>
#include <sstream>



namespace gle
{


const int	OpenGLExtensionsGen::m_supportedExtensionCount	= 574;
const int	OpenGLExtensionsGen::m_supportedProcCount		= 2434;


OpenGLExtensionsGen::OpenGLExtensionsGen( std::ostream* pOS )
:	OpenGLExtensions( pOS ),
	m_isSEDEnable( false )
{
	clear();
}


void OpenGLExtensionsGen::clear()
{
	m_initializedExtensionCount	= 0;
	m_initializedProcCount		= 0;

	m_initializedExtensions.clear();

#ifdef POSIX
	// ****** GLX_3DFX_multisample ******
	isGLX_3DFX_multisample = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_AMD_gpu_association ******
	isGLX_AMD_gpu_association = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_create_context ******
	isGLX_ARB_create_context = false;

	glXCreateContextAttribsARB = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_create_context_profile ******
	isGLX_ARB_create_context_profile = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_create_context_robustness ******
	isGLX_ARB_create_context_robustness = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_fbconfig_float ******
	isGLX_ARB_fbconfig_float = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_framebuffer_sRGB ******
	isGLX_ARB_framebuffer_sRGB = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_get_proc_address ******
	isGLX_ARB_get_proc_address = false;

	glXGetProcAddressARB = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_multisample ******
	isGLX_ARB_multisample = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_ARB_vertex_buffer_object ******
	isGLX_ARB_vertex_buffer_object = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_buffer_age ******
	isGLX_EXT_buffer_age = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_create_context_es2_profile ******
	isGLX_EXT_create_context_es2_profile = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_create_context_es_profile ******
	isGLX_EXT_create_context_es_profile = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_fbconfig_packed_float ******
	isGLX_EXT_fbconfig_packed_float = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_framebuffer_sRGB ******
	isGLX_EXT_framebuffer_sRGB = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_import_context ******
	isGLX_EXT_import_context = false;

	glXFreeContextEXT = 0;
	glXGetContextIDEXT = 0;
	glXGetCurrentDisplayEXT = 0;
	glXImportContextEXT = 0;
	glXQueryContextInfoEXT = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_swap_control ******
	isGLX_EXT_swap_control = false;

	glXSwapIntervalEXT = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_swap_control_tear ******
	isGLX_EXT_swap_control_tear = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_texture_from_pixmap ******
	isGLX_EXT_texture_from_pixmap = false;

	glXBindTexImageEXT = 0;
	glXReleaseTexImageEXT = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_visual_info ******
	isGLX_EXT_visual_info = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_EXT_visual_rating ******
	isGLX_EXT_visual_rating = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_INTEL_swap_event ******
	isGLX_INTEL_swap_event = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_MESA_agp_offset ******
	isGLX_MESA_agp_offset = false;

	glXGetAGPOffsetMESA = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_MESA_copy_sub_buffer ******
	isGLX_MESA_copy_sub_buffer = false;

	glXCopySubBufferMESA = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_MESA_pixmap_colormap ******
	isGLX_MESA_pixmap_colormap = false;

	glXCreateGLXPixmapMESA = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_MESA_release_buffers ******
	isGLX_MESA_release_buffers = false;

	glXReleaseBuffersMESA = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_MESA_set_3dfx_mode ******
	isGLX_MESA_set_3dfx_mode = false;

	glXSet3DfxModeMESA = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_copy_image ******
	isGLX_NV_copy_image = false;

	glXCopyImageSubDataNV = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_float_buffer ******
	isGLX_NV_float_buffer = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_multisample_coverage ******
	isGLX_NV_multisample_coverage = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_present_video ******
	isGLX_NV_present_video = false;

	glXBindVideoDeviceNV = 0;
	glXEnumerateVideoDevicesNV = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_swap_group ******
	isGLX_NV_swap_group = false;

	glXBindSwapBarrierNV = 0;
	glXJoinSwapGroupNV = 0;
	glXQueryFrameCountNV = 0;
	glXQueryMaxSwapGroupsNV = 0;
	glXQuerySwapGroupNV = 0;
	glXResetFrameCountNV = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_video_capture ******
	isGLX_NV_video_capture = false;

	glXBindVideoCaptureDeviceNV = 0;
	glXEnumerateVideoCaptureDevicesNV = 0;
	glXLockVideoCaptureDeviceNV = 0;
	glXQueryVideoCaptureDeviceNV = 0;
	glXReleaseVideoCaptureDeviceNV = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_video_out ******
	isGLX_NV_video_out = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_NV_video_output ******
	isGLX_NV_video_output = false;

	glXBindVideoImageNV = 0;
	glXGetVideoDeviceNV = 0;
	glXGetVideoInfoNV = 0;
	glXReleaseVideoDeviceNV = 0;
	glXReleaseVideoImageNV = 0;
	glXSendPbufferToVideoNV = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_OML_swap_method ******
	isGLX_OML_swap_method = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_OML_sync_control ******
	isGLX_OML_sync_control = false;

	glXGetMscRateOML = 0;
	glXGetSyncValuesOML = 0;
	glXSwapBuffersMscOML = 0;
	glXWaitForMscOML = 0;
	glXWaitForSbcOML = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIS_blended_overlay ******
	isGLX_SGIS_blended_overlay = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIS_multisample ******
	isGLX_SGIS_multisample = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIS_shared_multisample ******
	isGLX_SGIS_shared_multisample = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_dmbuffer ******
	isGLX_SGIX_dmbuffer = false;

//	glXAssociateDMPbufferSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_fbconfig ******
	isGLX_SGIX_fbconfig = false;

	glXChooseFBConfigSGIX = 0;
	glXCreateContextWithConfigSGIX = 0;
	glXCreateGLXPixmapWithConfigSGIX = 0;
	glXGetFBConfigAttribSGIX = 0;
	glXGetFBConfigFromVisualSGIX = 0;
	glXGetVisualFromFBConfigSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_hyperpipe ******
	isGLX_SGIX_hyperpipe = false;

	glXBindHyperpipeSGIX = 0;
	glXDestroyHyperpipeConfigSGIX = 0;
	glXHyperpipeAttribSGIX = 0;
	glXHyperpipeConfigSGIX = 0;
	glXQueryHyperpipeAttribSGIX = 0;
	glXQueryHyperpipeBestAttribSGIX = 0;
	glXQueryHyperpipeConfigSGIX = 0;
	glXQueryHyperpipeNetworkSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_pbuffer ******
	isGLX_SGIX_pbuffer = false;

	glXCreateGLXPbufferSGIX = 0;
	glXDestroyGLXPbufferSGIX = 0;
	glXGetSelectedEventSGIX = 0;
	glXQueryGLXPbufferSGIX = 0;
	glXSelectEventSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_swap_barrier ******
	isGLX_SGIX_swap_barrier = false;

	glXBindSwapBarrierSGIX = 0;
	glXQueryMaxSwapBarriersSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_swap_group ******
	isGLX_SGIX_swap_group = false;

	glXJoinSwapGroupSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_video_resize ******
	isGLX_SGIX_video_resize = false;

	glXBindChannelToWindowSGIX = 0;
	glXChannelRectSGIX = 0;
	glXChannelRectSyncSGIX = 0;
	glXQueryChannelDeltasSGIX = 0;
	glXQueryChannelRectSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_video_source ******
	isGLX_SGIX_video_source = false;

//	glXCreateGLXVideoSourceSGIX = 0;
//	glXDestroyGLXVideoSourceSGIX = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGIX_visual_select_group ******
	isGLX_SGIX_visual_select_group = false;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGI_cushion ******
	isGLX_SGI_cushion = false;

	glXCushionSGI = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGI_make_current_read ******
	isGLX_SGI_make_current_read = false;

	glXGetCurrentReadDrawableSGI = 0;
	glXMakeCurrentReadSGI = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGI_swap_control ******
	isGLX_SGI_swap_control = false;

	glXSwapIntervalSGI = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SGI_video_sync ******
	isGLX_SGI_video_sync = false;

	glXGetVideoSyncSGI = 0;
	glXWaitVideoSyncSGI = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_SUN_get_transparent_index ******
	isGLX_SUN_get_transparent_index = false;

	glXGetTransparentIndexSUN = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_VERSION_1_3 ******
	isGLX_VERSION_1_3 = false;

	glXChooseFBConfig = 0;
	glXCreateNewContext = 0;
	glXCreatePbuffer = 0;
	glXCreatePixmap = 0;
	glXCreateWindow = 0;
	glXDestroyPbuffer = 0;
	glXDestroyPixmap = 0;
	glXDestroyWindow = 0;
	glXGetCurrentDisplay = 0;
	glXGetCurrentReadDrawable = 0;
	glXGetFBConfigAttrib = 0;
	glXGetFBConfigs = 0;
	glXGetSelectedEvent = 0;
	glXGetVisualFromFBConfig = 0;
	glXMakeContextCurrent = 0;
	glXQueryContext = 0;
	glXQueryDrawable = 0;
	glXSelectEvent = 0;
#endif //POSIX

#ifdef POSIX
	// ****** GLX_VERSION_1_4 ******
	isGLX_VERSION_1_4 = false;

	glXGetProcAddress = 0;
#endif //POSIX


	// ****** GL_3DFX_multisample ******
	isGL_3DFX_multisample = false;

	// ****** GL_3DFX_tbuffer ******
	isGL_3DFX_tbuffer = false;

	glTbufferMask3DFX = 0;

	// ****** GL_3DFX_texture_compression_FXT1 ******
	isGL_3DFX_texture_compression_FXT1 = false;

	// ****** GL_AMD_blend_minmax_factor ******
	isGL_AMD_blend_minmax_factor = false;

	// ****** GL_AMD_conservative_depth ******
	isGL_AMD_conservative_depth = false;

	// ****** GL_AMD_debug_output ******
	isGL_AMD_debug_output = false;

	glDebugMessageCallbackAMD = 0;
	glDebugMessageEnableAMD = 0;
	glDebugMessageInsertAMD = 0;
	glGetDebugMessageLogAMD = 0;

	// ****** GL_AMD_depth_clamp_separate ******
	isGL_AMD_depth_clamp_separate = false;

	// ****** GL_AMD_draw_buffers_blend ******
	isGL_AMD_draw_buffers_blend = false;

	glBlendEquationIndexedAMD = 0;
	glBlendEquationSeparateIndexedAMD = 0;
	glBlendFuncIndexedAMD = 0;
	glBlendFuncSeparateIndexedAMD = 0;

	// ****** GL_AMD_multi_draw_indirect ******
	isGL_AMD_multi_draw_indirect = false;

	glMultiDrawArraysIndirectAMD = 0;
	glMultiDrawElementsIndirectAMD = 0;

	// ****** GL_AMD_name_gen_delete ******
	isGL_AMD_name_gen_delete = false;

	glDeleteNamesAMD = 0;
	glGenNamesAMD = 0;
	glIsNameAMD = 0;

	// ****** GL_AMD_performance_monitor ******
	isGL_AMD_performance_monitor = false;

	glBeginPerfMonitorAMD = 0;
	glDeletePerfMonitorsAMD = 0;
	glEndPerfMonitorAMD = 0;
	glGenPerfMonitorsAMD = 0;
	glGetPerfMonitorCounterDataAMD = 0;
	glGetPerfMonitorCounterInfoAMD = 0;
	glGetPerfMonitorCounterStringAMD = 0;
	glGetPerfMonitorCountersAMD = 0;
	glGetPerfMonitorGroupStringAMD = 0;
	glGetPerfMonitorGroupsAMD = 0;
	glSelectPerfMonitorCountersAMD = 0;

	// ****** GL_AMD_pinned_memory ******
	isGL_AMD_pinned_memory = false;

	// ****** GL_AMD_query_buffer_object ******
	isGL_AMD_query_buffer_object = false;

	// ****** GL_AMD_sample_positions ******
	isGL_AMD_sample_positions = false;

	glSetMultisamplefvAMD = 0;

	// ****** GL_AMD_seamless_cubemap_per_texture ******
	isGL_AMD_seamless_cubemap_per_texture = false;

	// ****** GL_AMD_shader_stencil_export ******
	isGL_AMD_shader_stencil_export = false;

	// ****** GL_AMD_shader_trinary_minmax ******
	isGL_AMD_shader_trinary_minmax = false;

	// ****** GL_AMD_sparse_texture ******
	isGL_AMD_sparse_texture = false;

	glTexStorageSparseAMD = 0;
	glTextureStorageSparseAMD = 0;

	// ****** GL_AMD_stencil_operation_extended ******
	isGL_AMD_stencil_operation_extended = false;

	glStencilOpValueAMD = 0;

	// ****** GL_AMD_texture_texture4 ******
	isGL_AMD_texture_texture4 = false;

	// ****** GL_AMD_transform_feedback3_lines_triangles ******
	isGL_AMD_transform_feedback3_lines_triangles = false;

	// ****** GL_AMD_vertex_shader_layer ******
	isGL_AMD_vertex_shader_layer = false;

	// ****** GL_AMD_vertex_shader_tesselator ******
	isGL_AMD_vertex_shader_tesselator = false;

	glTessellationFactorAMD = 0;
	glTessellationModeAMD = 0;

	// ****** GL_AMD_vertex_shader_viewport_index ******
	isGL_AMD_vertex_shader_viewport_index = false;

	// ****** GL_APPLE_aux_depth_stencil ******
	isGL_APPLE_aux_depth_stencil = false;

	// ****** GL_APPLE_client_storage ******
	isGL_APPLE_client_storage = false;

	// ****** GL_APPLE_element_array ******
	isGL_APPLE_element_array = false;

	glDrawElementArrayAPPLE = 0;
	glDrawRangeElementArrayAPPLE = 0;
	glElementPointerAPPLE = 0;
	glMultiDrawElementArrayAPPLE = 0;
	glMultiDrawRangeElementArrayAPPLE = 0;

	// ****** GL_APPLE_fence ******
	isGL_APPLE_fence = false;

	glDeleteFencesAPPLE = 0;
	glFinishFenceAPPLE = 0;
	glFinishObjectAPPLE = 0;
	glGenFencesAPPLE = 0;
	glIsFenceAPPLE = 0;
	glSetFenceAPPLE = 0;
	glTestFenceAPPLE = 0;
	glTestObjectAPPLE = 0;

	// ****** GL_APPLE_float_pixels ******
	isGL_APPLE_float_pixels = false;

	// ****** GL_APPLE_flush_buffer_range ******
	isGL_APPLE_flush_buffer_range = false;

	glBufferParameteriAPPLE = 0;
	glFlushMappedBufferRangeAPPLE = 0;

	// ****** GL_APPLE_object_purgeable ******
	isGL_APPLE_object_purgeable = false;

	glGetObjectParameterivAPPLE = 0;
	glObjectPurgeableAPPLE = 0;
	glObjectUnpurgeableAPPLE = 0;

	// ****** GL_APPLE_rgb_422 ******
	isGL_APPLE_rgb_422 = false;

	// ****** GL_APPLE_row_bytes ******
	isGL_APPLE_row_bytes = false;

	// ****** GL_APPLE_specular_vector ******
	isGL_APPLE_specular_vector = false;

	// ****** GL_APPLE_texture_range ******
	isGL_APPLE_texture_range = false;

	glGetTexParameterPointervAPPLE = 0;
	glTextureRangeAPPLE = 0;

	// ****** GL_APPLE_transform_hint ******
	isGL_APPLE_transform_hint = false;

	// ****** GL_APPLE_vertex_array_object ******
	isGL_APPLE_vertex_array_object = false;

	glBindVertexArrayAPPLE = 0;
	glDeleteVertexArraysAPPLE = 0;
	glGenVertexArraysAPPLE = 0;
	glIsVertexArrayAPPLE = 0;

	// ****** GL_APPLE_vertex_array_range ******
	isGL_APPLE_vertex_array_range = false;

	glFlushVertexArrayRangeAPPLE = 0;
	glVertexArrayParameteriAPPLE = 0;
	glVertexArrayRangeAPPLE = 0;

	// ****** GL_APPLE_vertex_program_evaluators ******
	isGL_APPLE_vertex_program_evaluators = false;

	glDisableVertexAttribAPPLE = 0;
	glEnableVertexAttribAPPLE = 0;
	glIsVertexAttribEnabledAPPLE = 0;
	glMapVertexAttrib1dAPPLE = 0;
	glMapVertexAttrib1fAPPLE = 0;
	glMapVertexAttrib2dAPPLE = 0;
	glMapVertexAttrib2fAPPLE = 0;

	// ****** GL_APPLE_ycbcr_422 ******
	isGL_APPLE_ycbcr_422 = false;

	// ****** GL_ARB_ES2_compatibility ******
	isGL_ARB_ES2_compatibility = false;

	glClearDepthf = 0;
	glDepthRangef = 0;
	glGetShaderPrecisionFormat = 0;
	glReleaseShaderCompiler = 0;
	glShaderBinary = 0;

	// ****** GL_ARB_ES3_compatibility ******
	isGL_ARB_ES3_compatibility = false;

	// ****** GL_ARB_arrays_of_arrays ******
	isGL_ARB_arrays_of_arrays = false;

	// ****** GL_ARB_base_instance ******
	isGL_ARB_base_instance = false;

	glDrawArraysInstancedBaseInstance = 0;
	glDrawElementsInstancedBaseInstance = 0;
	glDrawElementsInstancedBaseVertexBaseInstance = 0;

	// ****** GL_ARB_blend_func_extended ******
	isGL_ARB_blend_func_extended = false;

	glBindFragDataLocationIndexed = 0;
	glGetFragDataIndex = 0;

	// ****** GL_ARB_cl_event ******
	isGL_ARB_cl_event = false;

	glCreateSyncFromCLeventARB = 0;

	// ****** GL_ARB_clear_buffer_object ******
	isGL_ARB_clear_buffer_object = false;

	glClearBufferData = 0;
	glClearBufferSubData = 0;
	glClearNamedBufferDataEXT = 0;
	glClearNamedBufferSubDataEXT = 0;

	// ****** GL_ARB_color_buffer_float ******
	isGL_ARB_color_buffer_float = false;

	glClampColorARB = 0;

	// ****** GL_ARB_compatibility ******
	isGL_ARB_compatibility = false;

	// ****** GL_ARB_compressed_texture_pixel_storage ******
	isGL_ARB_compressed_texture_pixel_storage = false;

	// ****** GL_ARB_compute_shader ******
	isGL_ARB_compute_shader = false;

	glDispatchCompute = 0;
	glDispatchComputeIndirect = 0;

	// ****** GL_ARB_conservative_depth ******
	isGL_ARB_conservative_depth = false;

	// ****** GL_ARB_copy_buffer ******
	isGL_ARB_copy_buffer = false;

	glCopyBufferSubData = 0;

	// ****** GL_ARB_copy_image ******
	isGL_ARB_copy_image = false;

	glCopyImageSubData = 0;

	// ****** GL_ARB_debug_output ******
	isGL_ARB_debug_output = false;

	glDebugMessageCallbackARB = 0;
	glDebugMessageControlARB = 0;
	glDebugMessageInsertARB = 0;
	glGetDebugMessageLogARB = 0;

	// ****** GL_ARB_depth_buffer_float ******
	isGL_ARB_depth_buffer_float = false;

	// ****** GL_ARB_depth_clamp ******
	isGL_ARB_depth_clamp = false;

	// ****** GL_ARB_depth_texture ******
	isGL_ARB_depth_texture = false;

	// ****** GL_ARB_draw_buffers ******
	isGL_ARB_draw_buffers = false;

	glDrawBuffersARB = 0;

	// ****** GL_ARB_draw_buffers_blend ******
	isGL_ARB_draw_buffers_blend = false;

	glBlendEquationSeparateiARB = 0;
	glBlendEquationiARB = 0;
	glBlendFuncSeparateiARB = 0;
	glBlendFunciARB = 0;

	// ****** GL_ARB_draw_elements_base_vertex ******
	isGL_ARB_draw_elements_base_vertex = false;

	glDrawElementsBaseVertex = 0;
	glDrawElementsInstancedBaseVertex = 0;
	glDrawRangeElementsBaseVertex = 0;
	glMultiDrawElementsBaseVertex = 0;

	// ****** GL_ARB_draw_indirect ******
	isGL_ARB_draw_indirect = false;

	glDrawArraysIndirect = 0;
	glDrawElementsIndirect = 0;

	// ****** GL_ARB_draw_instanced ******
	isGL_ARB_draw_instanced = false;

	glDrawArraysInstancedARB = 0;
	glDrawElementsInstancedARB = 0;

	// ****** GL_ARB_explicit_attrib_location ******
	isGL_ARB_explicit_attrib_location = false;

	// ****** GL_ARB_explicit_uniform_location ******
	isGL_ARB_explicit_uniform_location = false;

	// ****** GL_ARB_fragment_coord_conventions ******
	isGL_ARB_fragment_coord_conventions = false;

	// ****** GL_ARB_fragment_layer_viewport ******
	isGL_ARB_fragment_layer_viewport = false;

	// ****** GL_ARB_fragment_program ******
	isGL_ARB_fragment_program = false;

	// ****** GL_ARB_fragment_program_shadow ******
	isGL_ARB_fragment_program_shadow = false;

	// ****** GL_ARB_fragment_shader ******
	isGL_ARB_fragment_shader = false;

	// ****** GL_ARB_framebuffer_no_attachments ******
	isGL_ARB_framebuffer_no_attachments = false;

	glFramebufferParameteri = 0;
	glGetFramebufferParameteriv = 0;
	glGetNamedFramebufferParameterivEXT = 0;
	glNamedFramebufferParameteriEXT = 0;

	// ****** GL_ARB_framebuffer_object ******
	isGL_ARB_framebuffer_object = false;

	glBindFramebuffer = 0;
	glBindRenderbuffer = 0;
	glBlitFramebuffer = 0;
	glCheckFramebufferStatus = 0;
	glDeleteFramebuffers = 0;
	glDeleteRenderbuffers = 0;
	glFramebufferRenderbuffer = 0;
	glFramebufferTexture1D = 0;
	glFramebufferTexture2D = 0;
	glFramebufferTexture3D = 0;
	glFramebufferTextureLayer = 0;
	glGenFramebuffers = 0;
	glGenRenderbuffers = 0;
	glGenerateMipmap = 0;
	glGetFramebufferAttachmentParameteriv = 0;
	glGetRenderbufferParameteriv = 0;
	glIsFramebuffer = 0;
	glIsRenderbuffer = 0;
	glRenderbufferStorage = 0;
	glRenderbufferStorageMultisample = 0;

	// ****** GL_ARB_framebuffer_sRGB ******
	isGL_ARB_framebuffer_sRGB = false;

	// ****** GL_ARB_geometry_shader4 ******
	isGL_ARB_geometry_shader4 = false;

	glFramebufferTextureARB = 0;
	glFramebufferTextureFaceARB = 0;
	glFramebufferTextureLayerARB = 0;
	glProgramParameteriARB = 0;

	// ****** GL_ARB_get_program_binary ******
	isGL_ARB_get_program_binary = false;

	glGetProgramBinary = 0;
	glProgramBinary = 0;
	glProgramParameteri = 0;

	// ****** GL_ARB_gpu_shader5 ******
	isGL_ARB_gpu_shader5 = false;

	// ****** GL_ARB_gpu_shader_fp64 ******
	isGL_ARB_gpu_shader_fp64 = false;

	glGetUniformdv = 0;
	glUniform1d = 0;
	glUniform1dv = 0;
	glUniform2d = 0;
	glUniform2dv = 0;
	glUniform3d = 0;
	glUniform3dv = 0;
	glUniform4d = 0;
	glUniform4dv = 0;
	glUniformMatrix2dv = 0;
	glUniformMatrix2x3dv = 0;
	glUniformMatrix2x4dv = 0;
	glUniformMatrix3dv = 0;
	glUniformMatrix3x2dv = 0;
	glUniformMatrix3x4dv = 0;
	glUniformMatrix4dv = 0;
	glUniformMatrix4x2dv = 0;
	glUniformMatrix4x3dv = 0;

	// ****** GL_ARB_half_float_pixel ******
	isGL_ARB_half_float_pixel = false;

	// ****** GL_ARB_half_float_vertex ******
	isGL_ARB_half_float_vertex = false;

	// ****** GL_ARB_imaging ******
	isGL_ARB_imaging = false;

	// ****** GL_ARB_instanced_arrays ******
	isGL_ARB_instanced_arrays = false;

	glVertexAttribDivisorARB = 0;

	// ****** GL_ARB_internalformat_query ******
	isGL_ARB_internalformat_query = false;

	glGetInternalformativ = 0;

	// ****** GL_ARB_internalformat_query2 ******
	isGL_ARB_internalformat_query2 = false;

	glGetInternalformati64v = 0;

	// ****** GL_ARB_invalidate_subdata ******
	isGL_ARB_invalidate_subdata = false;

	glInvalidateBufferData = 0;
	glInvalidateBufferSubData = 0;
	glInvalidateFramebuffer = 0;
	glInvalidateSubFramebuffer = 0;
	glInvalidateTexImage = 0;
	glInvalidateTexSubImage = 0;

	// ****** GL_ARB_map_buffer_alignment ******
	isGL_ARB_map_buffer_alignment = false;

	// ****** GL_ARB_map_buffer_range ******
	isGL_ARB_map_buffer_range = false;

	glFlushMappedBufferRange = 0;
	glMapBufferRange = 0;

	// ****** GL_ARB_matrix_palette ******
	isGL_ARB_matrix_palette = false;

	glCurrentPaletteMatrixARB = 0;
	glMatrixIndexPointerARB = 0;
	glMatrixIndexubvARB = 0;
	glMatrixIndexuivARB = 0;
	glMatrixIndexusvARB = 0;

	// ****** GL_ARB_multi_draw_indirect ******
	isGL_ARB_multi_draw_indirect = false;

	glMultiDrawArraysIndirect = 0;
	glMultiDrawElementsIndirect = 0;

	// ****** GL_ARB_multisample ******
	isGL_ARB_multisample = false;

	glSampleCoverageARB = 0;

	// ****** GL_ARB_multitexture ******
	isGL_ARB_multitexture = false;

	glActiveTextureARB = 0;
	glClientActiveTextureARB = 0;
	glMultiTexCoord1dARB = 0;
	glMultiTexCoord1dvARB = 0;
	glMultiTexCoord1fARB = 0;
	glMultiTexCoord1fvARB = 0;
	glMultiTexCoord1iARB = 0;
	glMultiTexCoord1ivARB = 0;
	glMultiTexCoord1sARB = 0;
	glMultiTexCoord1svARB = 0;
	glMultiTexCoord2dARB = 0;
	glMultiTexCoord2dvARB = 0;
	glMultiTexCoord2fARB = 0;
	glMultiTexCoord2fvARB = 0;
	glMultiTexCoord2iARB = 0;
	glMultiTexCoord2ivARB = 0;
	glMultiTexCoord2sARB = 0;
	glMultiTexCoord2svARB = 0;
	glMultiTexCoord3dARB = 0;
	glMultiTexCoord3dvARB = 0;
	glMultiTexCoord3fARB = 0;
	glMultiTexCoord3fvARB = 0;
	glMultiTexCoord3iARB = 0;
	glMultiTexCoord3ivARB = 0;
	glMultiTexCoord3sARB = 0;
	glMultiTexCoord3svARB = 0;
	glMultiTexCoord4dARB = 0;
	glMultiTexCoord4dvARB = 0;
	glMultiTexCoord4fARB = 0;
	glMultiTexCoord4fvARB = 0;
	glMultiTexCoord4iARB = 0;
	glMultiTexCoord4ivARB = 0;
	glMultiTexCoord4sARB = 0;
	glMultiTexCoord4svARB = 0;

	// ****** GL_ARB_occlusion_query ******
	isGL_ARB_occlusion_query = false;

	glBeginQueryARB = 0;
	glDeleteQueriesARB = 0;
	glEndQueryARB = 0;
	glGenQueriesARB = 0;
	glGetQueryObjectivARB = 0;
	glGetQueryObjectuivARB = 0;
	glGetQueryivARB = 0;
	glIsQueryARB = 0;

	// ****** GL_ARB_occlusion_query2 ******
	isGL_ARB_occlusion_query2 = false;

	// ****** GL_ARB_pixel_buffer_object ******
	isGL_ARB_pixel_buffer_object = false;

	// ****** GL_ARB_point_parameters ******
	isGL_ARB_point_parameters = false;

	glPointParameterfARB = 0;
	glPointParameterfvARB = 0;

	// ****** GL_ARB_point_sprite ******
	isGL_ARB_point_sprite = false;

	// ****** GL_ARB_program_interface_query ******
	isGL_ARB_program_interface_query = false;

	glGetProgramInterfaceiv = 0;
	glGetProgramResourceIndex = 0;
	glGetProgramResourceLocation = 0;
	glGetProgramResourceLocationIndex = 0;
	glGetProgramResourceName = 0;
	glGetProgramResourceiv = 0;

	// ****** GL_ARB_provoking_vertex ******
	isGL_ARB_provoking_vertex = false;

	glProvokingVertex = 0;

	// ****** GL_ARB_robust_buffer_access_behavior ******
	isGL_ARB_robust_buffer_access_behavior = false;

	// ****** GL_ARB_robustness ******
	isGL_ARB_robustness = false;

	glGetGraphicsResetStatusARB = 0;
	glGetnColorTableARB = 0;
	glGetnCompressedTexImageARB = 0;
	glGetnConvolutionFilterARB = 0;
	glGetnHistogramARB = 0;
	glGetnMapdvARB = 0;
	glGetnMapfvARB = 0;
	glGetnMapivARB = 0;
	glGetnMinmaxARB = 0;
	glGetnPixelMapfvARB = 0;
	glGetnPixelMapuivARB = 0;
	glGetnPixelMapusvARB = 0;
	glGetnPolygonStippleARB = 0;
	glGetnSeparableFilterARB = 0;
	glGetnTexImageARB = 0;
	glGetnUniformdvARB = 0;
	glGetnUniformfvARB = 0;
	glGetnUniformivARB = 0;
	glGetnUniformuivARB = 0;
	glReadnPixelsARB = 0;

	// ****** GL_ARB_robustness_isolation ******
	isGL_ARB_robustness_isolation = false;

	// ****** GL_ARB_sample_shading ******
	isGL_ARB_sample_shading = false;

	glMinSampleShadingARB = 0;

	// ****** GL_ARB_sampler_objects ******
	isGL_ARB_sampler_objects = false;

	glBindSampler = 0;
	glDeleteSamplers = 0;
	glGenSamplers = 0;
	glGetSamplerParameterIiv = 0;
	glGetSamplerParameterIuiv = 0;
	glGetSamplerParameterfv = 0;
	glGetSamplerParameteriv = 0;
	glIsSampler = 0;
	glSamplerParameterIiv = 0;
	glSamplerParameterIuiv = 0;
	glSamplerParameterf = 0;
	glSamplerParameterfv = 0;
	glSamplerParameteri = 0;
	glSamplerParameteriv = 0;

	// ****** GL_ARB_seamless_cube_map ******
	isGL_ARB_seamless_cube_map = false;

	// ****** GL_ARB_separate_shader_objects ******
	isGL_ARB_separate_shader_objects = false;

	glActiveShaderProgram = 0;
	glBindProgramPipeline = 0;
	glCreateShaderProgramv = 0;
	glDeleteProgramPipelines = 0;
	glGenProgramPipelines = 0;
	glGetProgramPipelineInfoLog = 0;
	glGetProgramPipelineiv = 0;
	glIsProgramPipeline = 0;
	glProgramUniform1d = 0;
	glProgramUniform1dv = 0;
	glProgramUniform1f = 0;
	glProgramUniform1fv = 0;
	glProgramUniform1i = 0;
	glProgramUniform1iv = 0;
	glProgramUniform1ui = 0;
	glProgramUniform1uiv = 0;
	glProgramUniform2d = 0;
	glProgramUniform2dv = 0;
	glProgramUniform2f = 0;
	glProgramUniform2fv = 0;
	glProgramUniform2i = 0;
	glProgramUniform2iv = 0;
	glProgramUniform2ui = 0;
	glProgramUniform2uiv = 0;
	glProgramUniform3d = 0;
	glProgramUniform3dv = 0;
	glProgramUniform3f = 0;
	glProgramUniform3fv = 0;
	glProgramUniform3i = 0;
	glProgramUniform3iv = 0;
	glProgramUniform3ui = 0;
	glProgramUniform3uiv = 0;
	glProgramUniform4d = 0;
	glProgramUniform4dv = 0;
	glProgramUniform4f = 0;
	glProgramUniform4fv = 0;
	glProgramUniform4i = 0;
	glProgramUniform4iv = 0;
	glProgramUniform4ui = 0;
	glProgramUniform4uiv = 0;
	glProgramUniformMatrix2dv = 0;
	glProgramUniformMatrix2fv = 0;
	glProgramUniformMatrix2x3dv = 0;
	glProgramUniformMatrix2x3fv = 0;
	glProgramUniformMatrix2x4dv = 0;
	glProgramUniformMatrix2x4fv = 0;
	glProgramUniformMatrix3dv = 0;
	glProgramUniformMatrix3fv = 0;
	glProgramUniformMatrix3x2dv = 0;
	glProgramUniformMatrix3x2fv = 0;
	glProgramUniformMatrix3x4dv = 0;
	glProgramUniformMatrix3x4fv = 0;
	glProgramUniformMatrix4dv = 0;
	glProgramUniformMatrix4fv = 0;
	glProgramUniformMatrix4x2dv = 0;
	glProgramUniformMatrix4x2fv = 0;
	glProgramUniformMatrix4x3dv = 0;
	glProgramUniformMatrix4x3fv = 0;
	glUseProgramStages = 0;
	glValidateProgramPipeline = 0;

	// ****** GL_ARB_shader_atomic_counters ******
	isGL_ARB_shader_atomic_counters = false;

	glGetActiveAtomicCounterBufferiv = 0;

	// ****** GL_ARB_shader_bit_encoding ******
	isGL_ARB_shader_bit_encoding = false;

	// ****** GL_ARB_shader_image_load_store ******
	isGL_ARB_shader_image_load_store = false;

	glBindImageTexture = 0;
	glMemoryBarrier = 0;

	// ****** GL_ARB_shader_image_size ******
	isGL_ARB_shader_image_size = false;

	// ****** GL_ARB_shader_objects ******
	isGL_ARB_shader_objects = false;

	glAttachObjectARB = 0;
	glCompileShaderARB = 0;
	glCreateProgramObjectARB = 0;
	glCreateShaderObjectARB = 0;
	glDeleteObjectARB = 0;
	glDetachObjectARB = 0;
	glGetActiveUniformARB = 0;
	glGetAttachedObjectsARB = 0;
	glGetHandleARB = 0;
	glGetInfoLogARB = 0;
	glGetObjectParameterfvARB = 0;
	glGetObjectParameterivARB = 0;
	glGetShaderSourceARB = 0;
	glGetUniformLocationARB = 0;
	glGetUniformfvARB = 0;
	glGetUniformivARB = 0;
	glLinkProgramARB = 0;
	glShaderSourceARB = 0;
	glUniform1fARB = 0;
	glUniform1fvARB = 0;
	glUniform1iARB = 0;
	glUniform1ivARB = 0;
	glUniform2fARB = 0;
	glUniform2fvARB = 0;
	glUniform2iARB = 0;
	glUniform2ivARB = 0;
	glUniform3fARB = 0;
	glUniform3fvARB = 0;
	glUniform3iARB = 0;
	glUniform3ivARB = 0;
	glUniform4fARB = 0;
	glUniform4fvARB = 0;
	glUniform4iARB = 0;
	glUniform4ivARB = 0;
	glUniformMatrix2fvARB = 0;
	glUniformMatrix3fvARB = 0;
	glUniformMatrix4fvARB = 0;
	glUseProgramObjectARB = 0;
	glValidateProgramARB = 0;

	// ****** GL_ARB_shader_precision ******
	isGL_ARB_shader_precision = false;

	// ****** GL_ARB_shader_stencil_export ******
	isGL_ARB_shader_stencil_export = false;

	// ****** GL_ARB_shader_storage_buffer_object ******
	isGL_ARB_shader_storage_buffer_object = false;

	glShaderStorageBlockBinding = 0;

	// ****** GL_ARB_shader_subroutine ******
	isGL_ARB_shader_subroutine = false;

	glGetActiveSubroutineName = 0;
	glGetActiveSubroutineUniformName = 0;
	glGetActiveSubroutineUniformiv = 0;
	glGetProgramStageiv = 0;
	glGetSubroutineIndex = 0;
	glGetSubroutineUniformLocation = 0;
	glGetUniformSubroutineuiv = 0;
	glUniformSubroutinesuiv = 0;

	// ****** GL_ARB_shader_texture_lod ******
	isGL_ARB_shader_texture_lod = false;

	// ****** GL_ARB_shading_language_100 ******
	isGL_ARB_shading_language_100 = false;

	// ****** GL_ARB_shading_language_420pack ******
	isGL_ARB_shading_language_420pack = false;

	// ****** GL_ARB_shading_language_include ******
	isGL_ARB_shading_language_include = false;

	glCompileShaderIncludeARB = 0;
	glDeleteNamedStringARB = 0;
	glGetNamedStringARB = 0;
	glGetNamedStringivARB = 0;
	glIsNamedStringARB = 0;
	glNamedStringARB = 0;

	// ****** GL_ARB_shading_language_packing ******
	isGL_ARB_shading_language_packing = false;

	// ****** GL_ARB_shadow ******
	isGL_ARB_shadow = false;

	// ****** GL_ARB_shadow_ambient ******
	isGL_ARB_shadow_ambient = false;

	// ****** GL_ARB_stencil_texturing ******
	isGL_ARB_stencil_texturing = false;

	// ****** GL_ARB_sync ******
	isGL_ARB_sync = false;

	glClientWaitSync = 0;
	glDeleteSync = 0;
	glFenceSync = 0;
	glGetInteger64v = 0;
	glGetSynciv = 0;
	glIsSync = 0;
	glWaitSync = 0;

	// ****** GL_ARB_tessellation_shader ******
	isGL_ARB_tessellation_shader = false;

	glPatchParameterfv = 0;
	glPatchParameteri = 0;

	// ****** GL_ARB_texture_border_clamp ******
	isGL_ARB_texture_border_clamp = false;

	// ****** GL_ARB_texture_buffer_object ******
	isGL_ARB_texture_buffer_object = false;

	glTexBufferARB = 0;

	// ****** GL_ARB_texture_buffer_object_rgb32 ******
	isGL_ARB_texture_buffer_object_rgb32 = false;

	// ****** GL_ARB_texture_buffer_range ******
	isGL_ARB_texture_buffer_range = false;

	glTexBufferRange = 0;
	glTextureBufferRangeEXT = 0;

	// ****** GL_ARB_texture_compression ******
	isGL_ARB_texture_compression = false;

	glCompressedTexImage1DARB = 0;
	glCompressedTexImage2DARB = 0;
	glCompressedTexImage3DARB = 0;
	glCompressedTexSubImage1DARB = 0;
	glCompressedTexSubImage2DARB = 0;
	glCompressedTexSubImage3DARB = 0;
	glGetCompressedTexImageARB = 0;

	// ****** GL_ARB_texture_compression_bptc ******
	isGL_ARB_texture_compression_bptc = false;

	// ****** GL_ARB_texture_compression_rgtc ******
	isGL_ARB_texture_compression_rgtc = false;

	// ****** GL_ARB_texture_cube_map ******
	isGL_ARB_texture_cube_map = false;

	// ****** GL_ARB_texture_cube_map_array ******
	isGL_ARB_texture_cube_map_array = false;

	// ****** GL_ARB_texture_env_add ******
	isGL_ARB_texture_env_add = false;

	// ****** GL_ARB_texture_env_combine ******
	isGL_ARB_texture_env_combine = false;

	// ****** GL_ARB_texture_env_crossbar ******
	isGL_ARB_texture_env_crossbar = false;

	// ****** GL_ARB_texture_env_dot3 ******
	isGL_ARB_texture_env_dot3 = false;

	// ****** GL_ARB_texture_float ******
	isGL_ARB_texture_float = false;

	// ****** GL_ARB_texture_gather ******
	isGL_ARB_texture_gather = false;

	// ****** GL_ARB_texture_mirrored_repeat ******
	isGL_ARB_texture_mirrored_repeat = false;

	// ****** GL_ARB_texture_multisample ******
	isGL_ARB_texture_multisample = false;

	glGetMultisamplefv = 0;
	glSampleMaski = 0;
	glTexImage2DMultisample = 0;
	glTexImage3DMultisample = 0;

	// ****** GL_ARB_texture_non_power_of_two ******
	isGL_ARB_texture_non_power_of_two = false;

	// ****** GL_ARB_texture_query_levels ******
	isGL_ARB_texture_query_levels = false;

	// ****** GL_ARB_texture_query_lod ******
	isGL_ARB_texture_query_lod = false;

	// ****** GL_ARB_texture_rectangle ******
	isGL_ARB_texture_rectangle = false;

	// ****** GL_ARB_texture_rg ******
	isGL_ARB_texture_rg = false;

	// ****** GL_ARB_texture_rgb10_a2ui ******
	isGL_ARB_texture_rgb10_a2ui = false;

	// ****** GL_ARB_texture_storage ******
	isGL_ARB_texture_storage = false;

	glTexStorage1D = 0;
	glTexStorage2D = 0;
	glTexStorage3D = 0;
	glTextureStorage1DEXT = 0;
	glTextureStorage2DEXT = 0;
	glTextureStorage3DEXT = 0;

	// ****** GL_ARB_texture_storage_multisample ******
	isGL_ARB_texture_storage_multisample = false;

	glTexStorage2DMultisample = 0;
	glTexStorage3DMultisample = 0;
	glTextureStorage2DMultisampleEXT = 0;
	glTextureStorage3DMultisampleEXT = 0;

	// ****** GL_ARB_texture_swizzle ******
	isGL_ARB_texture_swizzle = false;

	// ****** GL_ARB_texture_view ******
	isGL_ARB_texture_view = false;

	glTextureView = 0;

	// ****** GL_ARB_timer_query ******
	isGL_ARB_timer_query = false;

	glGetQueryObjecti64v = 0;
	glGetQueryObjectui64v = 0;
	glQueryCounter = 0;

	// ****** GL_ARB_transform_feedback2 ******
	isGL_ARB_transform_feedback2 = false;

	glBindTransformFeedback = 0;
	glDeleteTransformFeedbacks = 0;
	glDrawTransformFeedback = 0;
	glGenTransformFeedbacks = 0;
	glIsTransformFeedback = 0;
	glPauseTransformFeedback = 0;
	glResumeTransformFeedback = 0;

	// ****** GL_ARB_transform_feedback3 ******
	isGL_ARB_transform_feedback3 = false;

	glBeginQueryIndexed = 0;
	glDrawTransformFeedbackStream = 0;
	glEndQueryIndexed = 0;
	glGetQueryIndexediv = 0;

	// ****** GL_ARB_transform_feedback_instanced ******
	isGL_ARB_transform_feedback_instanced = false;

	glDrawTransformFeedbackInstanced = 0;
	glDrawTransformFeedbackStreamInstanced = 0;

	// ****** GL_ARB_transpose_matrix ******
	isGL_ARB_transpose_matrix = false;

	glLoadTransposeMatrixdARB = 0;
	glLoadTransposeMatrixfARB = 0;
	glMultTransposeMatrixdARB = 0;
	glMultTransposeMatrixfARB = 0;

	// ****** GL_ARB_uniform_buffer_object ******
	isGL_ARB_uniform_buffer_object = false;

	glGetActiveUniformBlockName = 0;
	glGetActiveUniformBlockiv = 0;
	glGetActiveUniformName = 0;
	glGetActiveUniformsiv = 0;
	glGetUniformBlockIndex = 0;
	glGetUniformIndices = 0;
	glUniformBlockBinding = 0;

	// ****** GL_ARB_vertex_array_bgra ******
	isGL_ARB_vertex_array_bgra = false;

	// ****** GL_ARB_vertex_array_object ******
	isGL_ARB_vertex_array_object = false;

	glBindVertexArray = 0;
	glDeleteVertexArrays = 0;
	glGenVertexArrays = 0;
	glIsVertexArray = 0;

	// ****** GL_ARB_vertex_attrib_64bit ******
	isGL_ARB_vertex_attrib_64bit = false;

	glGetVertexAttribLdv = 0;
	glVertexAttribL1d = 0;
	glVertexAttribL1dv = 0;
	glVertexAttribL2d = 0;
	glVertexAttribL2dv = 0;
	glVertexAttribL3d = 0;
	glVertexAttribL3dv = 0;
	glVertexAttribL4d = 0;
	glVertexAttribL4dv = 0;
	glVertexAttribLPointer = 0;

	// ****** GL_ARB_vertex_attrib_binding ******
	isGL_ARB_vertex_attrib_binding = false;

	glBindVertexBuffer = 0;
	glVertexArrayBindVertexBufferEXT = 0;
	glVertexArrayVertexAttribBindingEXT = 0;
	glVertexArrayVertexAttribFormatEXT = 0;
	glVertexArrayVertexAttribIFormatEXT = 0;
	glVertexArrayVertexAttribLFormatEXT = 0;
	glVertexArrayVertexBindingDivisorEXT = 0;
	glVertexAttribBinding = 0;
	glVertexAttribFormat = 0;
	glVertexAttribIFormat = 0;
	glVertexAttribLFormat = 0;
	glVertexBindingDivisor = 0;

	// ****** GL_ARB_vertex_blend ******
	isGL_ARB_vertex_blend = false;

	glVertexBlendARB = 0;
	glWeightPointerARB = 0;
	glWeightbvARB = 0;
	glWeightdvARB = 0;
	glWeightfvARB = 0;
	glWeightivARB = 0;
	glWeightsvARB = 0;
	glWeightubvARB = 0;
	glWeightuivARB = 0;
	glWeightusvARB = 0;

	// ****** GL_ARB_vertex_buffer_object ******
	isGL_ARB_vertex_buffer_object = false;

	glBindBufferARB = 0;
	glBufferDataARB = 0;
	glBufferSubDataARB = 0;
	glDeleteBuffersARB = 0;
	glGenBuffersARB = 0;
	glGetBufferParameterivARB = 0;
	glGetBufferPointervARB = 0;
	glGetBufferSubDataARB = 0;
	glIsBufferARB = 0;
	glMapBufferARB = 0;
	glUnmapBufferARB = 0;

	// ****** GL_ARB_vertex_program ******
	isGL_ARB_vertex_program = false;

	glBindProgramARB = 0;
	glDeleteProgramsARB = 0;
	glDisableVertexAttribArrayARB = 0;
	glEnableVertexAttribArrayARB = 0;
	glGenProgramsARB = 0;
	glGetProgramEnvParameterdvARB = 0;
	glGetProgramEnvParameterfvARB = 0;
	glGetProgramLocalParameterdvARB = 0;
	glGetProgramLocalParameterfvARB = 0;
	glGetProgramStringARB = 0;
	glGetProgramivARB = 0;
	glGetVertexAttribPointervARB = 0;
	glGetVertexAttribdvARB = 0;
	glGetVertexAttribfvARB = 0;
	glGetVertexAttribivARB = 0;
	glIsProgramARB = 0;
	glProgramEnvParameter4dARB = 0;
	glProgramEnvParameter4dvARB = 0;
	glProgramEnvParameter4fARB = 0;
	glProgramEnvParameter4fvARB = 0;
	glProgramLocalParameter4dARB = 0;
	glProgramLocalParameter4dvARB = 0;
	glProgramLocalParameter4fARB = 0;
	glProgramLocalParameter4fvARB = 0;
	glProgramStringARB = 0;
	glVertexAttrib1dARB = 0;
	glVertexAttrib1dvARB = 0;
	glVertexAttrib1fARB = 0;
	glVertexAttrib1fvARB = 0;
	glVertexAttrib1sARB = 0;
	glVertexAttrib1svARB = 0;
	glVertexAttrib2dARB = 0;
	glVertexAttrib2dvARB = 0;
	glVertexAttrib2fARB = 0;
	glVertexAttrib2fvARB = 0;
	glVertexAttrib2sARB = 0;
	glVertexAttrib2svARB = 0;
	glVertexAttrib3dARB = 0;
	glVertexAttrib3dvARB = 0;
	glVertexAttrib3fARB = 0;
	glVertexAttrib3fvARB = 0;
	glVertexAttrib3sARB = 0;
	glVertexAttrib3svARB = 0;
	glVertexAttrib4NbvARB = 0;
	glVertexAttrib4NivARB = 0;
	glVertexAttrib4NsvARB = 0;
	glVertexAttrib4NubARB = 0;
	glVertexAttrib4NubvARB = 0;
	glVertexAttrib4NuivARB = 0;
	glVertexAttrib4NusvARB = 0;
	glVertexAttrib4bvARB = 0;
	glVertexAttrib4dARB = 0;
	glVertexAttrib4dvARB = 0;
	glVertexAttrib4fARB = 0;
	glVertexAttrib4fvARB = 0;
	glVertexAttrib4ivARB = 0;
	glVertexAttrib4sARB = 0;
	glVertexAttrib4svARB = 0;
	glVertexAttrib4ubvARB = 0;
	glVertexAttrib4uivARB = 0;
	glVertexAttrib4usvARB = 0;
	glVertexAttribPointerARB = 0;

	// ****** GL_ARB_vertex_shader ******
	isGL_ARB_vertex_shader = false;

	glBindAttribLocationARB = 0;
	glGetActiveAttribARB = 0;
	glGetAttribLocationARB = 0;

	// ****** GL_ARB_vertex_type_2_10_10_10_rev ******
	isGL_ARB_vertex_type_2_10_10_10_rev = false;

	glColorP3ui = 0;
	glColorP3uiv = 0;
	glColorP4ui = 0;
	glColorP4uiv = 0;
	glMultiTexCoordP1ui = 0;
	glMultiTexCoordP1uiv = 0;
	glMultiTexCoordP2ui = 0;
	glMultiTexCoordP2uiv = 0;
	glMultiTexCoordP3ui = 0;
	glMultiTexCoordP3uiv = 0;
	glMultiTexCoordP4ui = 0;
	glMultiTexCoordP4uiv = 0;
	glNormalP3ui = 0;
	glNormalP3uiv = 0;
	glSecondaryColorP3ui = 0;
	glSecondaryColorP3uiv = 0;
	glTexCoordP1ui = 0;
	glTexCoordP1uiv = 0;
	glTexCoordP2ui = 0;
	glTexCoordP2uiv = 0;
	glTexCoordP3ui = 0;
	glTexCoordP3uiv = 0;
	glTexCoordP4ui = 0;
	glTexCoordP4uiv = 0;
	glVertexAttribP1ui = 0;
	glVertexAttribP1uiv = 0;
	glVertexAttribP2ui = 0;
	glVertexAttribP2uiv = 0;
	glVertexAttribP3ui = 0;
	glVertexAttribP3uiv = 0;
	glVertexAttribP4ui = 0;
	glVertexAttribP4uiv = 0;
	glVertexP2ui = 0;
	glVertexP2uiv = 0;
	glVertexP3ui = 0;
	glVertexP3uiv = 0;
	glVertexP4ui = 0;
	glVertexP4uiv = 0;

	// ****** GL_ARB_viewport_array ******
	isGL_ARB_viewport_array = false;

	glDepthRangeArrayv = 0;
	glDepthRangeIndexed = 0;
	glGetDoublei_v = 0;
	glGetFloati_v = 0;
	glScissorArrayv = 0;
	glScissorIndexed = 0;
	glScissorIndexedv = 0;
	glViewportArrayv = 0;
	glViewportIndexedf = 0;
	glViewportIndexedfv = 0;

	// ****** GL_ARB_window_pos ******
	isGL_ARB_window_pos = false;

	glWindowPos2dARB = 0;
	glWindowPos2dvARB = 0;
	glWindowPos2fARB = 0;
	glWindowPos2fvARB = 0;
	glWindowPos2iARB = 0;
	glWindowPos2ivARB = 0;
	glWindowPos2sARB = 0;
	glWindowPos2svARB = 0;
	glWindowPos3dARB = 0;
	glWindowPos3dvARB = 0;
	glWindowPos3fARB = 0;
	glWindowPos3fvARB = 0;
	glWindowPos3iARB = 0;
	glWindowPos3ivARB = 0;
	glWindowPos3sARB = 0;
	glWindowPos3svARB = 0;

	// ****** GL_ATI_draw_buffers ******
	isGL_ATI_draw_buffers = false;

	glDrawBuffersATI = 0;

	// ****** GL_ATI_element_array ******
	isGL_ATI_element_array = false;

	glDrawElementArrayATI = 0;
	glDrawRangeElementArrayATI = 0;
	glElementPointerATI = 0;

	// ****** GL_ATI_envmap_bumpmap ******
	isGL_ATI_envmap_bumpmap = false;

	glGetTexBumpParameterfvATI = 0;
	glGetTexBumpParameterivATI = 0;
	glTexBumpParameterfvATI = 0;
	glTexBumpParameterivATI = 0;

	// ****** GL_ATI_fragment_shader ******
	isGL_ATI_fragment_shader = false;

	glAlphaFragmentOp1ATI = 0;
	glAlphaFragmentOp2ATI = 0;
	glAlphaFragmentOp3ATI = 0;
	glBeginFragmentShaderATI = 0;
	glBindFragmentShaderATI = 0;
	glColorFragmentOp1ATI = 0;
	glColorFragmentOp2ATI = 0;
	glColorFragmentOp3ATI = 0;
	glDeleteFragmentShaderATI = 0;
	glEndFragmentShaderATI = 0;
	glGenFragmentShadersATI = 0;
	glPassTexCoordATI = 0;
	glSampleMapATI = 0;
	glSetFragmentShaderConstantATI = 0;

	// ****** GL_ATI_map_object_buffer ******
	isGL_ATI_map_object_buffer = false;

	glMapObjectBufferATI = 0;
	glUnmapObjectBufferATI = 0;

	// ****** GL_ATI_meminfo ******
	isGL_ATI_meminfo = false;

	// ****** GL_ATI_pixel_format_float ******
	isGL_ATI_pixel_format_float = false;

	// ****** GL_ATI_pn_triangles ******
	isGL_ATI_pn_triangles = false;

	glPNTrianglesfATI = 0;
	glPNTrianglesiATI = 0;

	// ****** GL_ATI_separate_stencil ******
	isGL_ATI_separate_stencil = false;

	glStencilFuncSeparateATI = 0;
	glStencilOpSeparateATI = 0;

	// ****** GL_ATI_text_fragment_shader ******
	isGL_ATI_text_fragment_shader = false;

	// ****** GL_ATI_texture_env_combine3 ******
	isGL_ATI_texture_env_combine3 = false;

	// ****** GL_ATI_texture_float ******
	isGL_ATI_texture_float = false;

	// ****** GL_ATI_texture_mirror_once ******
	isGL_ATI_texture_mirror_once = false;

	// ****** GL_ATI_vertex_array_object ******
	isGL_ATI_vertex_array_object = false;

	glArrayObjectATI = 0;
	glFreeObjectBufferATI = 0;
	glGetArrayObjectfvATI = 0;
	glGetArrayObjectivATI = 0;
	glGetObjectBufferfvATI = 0;
	glGetObjectBufferivATI = 0;
	glGetVariantArrayObjectfvATI = 0;
	glGetVariantArrayObjectivATI = 0;
	glIsObjectBufferATI = 0;
	glNewObjectBufferATI = 0;
	glUpdateObjectBufferATI = 0;
	glVariantArrayObjectATI = 0;

	// ****** GL_ATI_vertex_attrib_array_object ******
	isGL_ATI_vertex_attrib_array_object = false;

	glGetVertexAttribArrayObjectfvATI = 0;
	glGetVertexAttribArrayObjectivATI = 0;
	glVertexAttribArrayObjectATI = 0;

	// ****** GL_ATI_vertex_streams ******
	isGL_ATI_vertex_streams = false;

	glClientActiveVertexStreamATI = 0;
	glNormalStream3bATI = 0;
	glNormalStream3bvATI = 0;
	glNormalStream3dATI = 0;
	glNormalStream3dvATI = 0;
	glNormalStream3fATI = 0;
	glNormalStream3fvATI = 0;
	glNormalStream3iATI = 0;
	glNormalStream3ivATI = 0;
	glNormalStream3sATI = 0;
	glNormalStream3svATI = 0;
	glVertexBlendEnvfATI = 0;
	glVertexBlendEnviATI = 0;
	glVertexStream1dATI = 0;
	glVertexStream1dvATI = 0;
	glVertexStream1fATI = 0;
	glVertexStream1fvATI = 0;
	glVertexStream1iATI = 0;
	glVertexStream1ivATI = 0;
	glVertexStream1sATI = 0;
	glVertexStream1svATI = 0;
	glVertexStream2dATI = 0;
	glVertexStream2dvATI = 0;
	glVertexStream2fATI = 0;
	glVertexStream2fvATI = 0;
	glVertexStream2iATI = 0;
	glVertexStream2ivATI = 0;
	glVertexStream2sATI = 0;
	glVertexStream2svATI = 0;
	glVertexStream3dATI = 0;
	glVertexStream3dvATI = 0;
	glVertexStream3fATI = 0;
	glVertexStream3fvATI = 0;
	glVertexStream3iATI = 0;
	glVertexStream3ivATI = 0;
	glVertexStream3sATI = 0;
	glVertexStream3svATI = 0;
	glVertexStream4dATI = 0;
	glVertexStream4dvATI = 0;
	glVertexStream4fATI = 0;
	glVertexStream4fvATI = 0;
	glVertexStream4iATI = 0;
	glVertexStream4ivATI = 0;
	glVertexStream4sATI = 0;
	glVertexStream4svATI = 0;

	// ****** GL_EXT_422_pixels ******
	isGL_EXT_422_pixels = false;

	// ****** GL_EXT_abgr ******
	isGL_EXT_abgr = false;

	// ****** GL_EXT_bgra ******
	isGL_EXT_bgra = false;

	// ****** GL_EXT_bindable_uniform ******
	isGL_EXT_bindable_uniform = false;

	glGetUniformBufferSizeEXT = 0;
	glGetUniformOffsetEXT = 0;
	glUniformBufferEXT = 0;

	// ****** GL_EXT_blend_color ******
	isGL_EXT_blend_color = false;

	glBlendColorEXT = 0;

	// ****** GL_EXT_blend_equation_separate ******
	isGL_EXT_blend_equation_separate = false;

	glBlendEquationSeparateEXT = 0;

	// ****** GL_EXT_blend_func_separate ******
	isGL_EXT_blend_func_separate = false;

	glBlendFuncSeparateEXT = 0;

	// ****** GL_EXT_blend_logic_op ******
	isGL_EXT_blend_logic_op = false;

	// ****** GL_EXT_blend_minmax ******
	isGL_EXT_blend_minmax = false;

	glBlendEquationEXT = 0;

	// ****** GL_EXT_blend_subtract ******
	isGL_EXT_blend_subtract = false;

	// ****** GL_EXT_clip_volume_hint ******
	isGL_EXT_clip_volume_hint = false;

	// ****** GL_EXT_cmyka ******
	isGL_EXT_cmyka = false;

	// ****** GL_EXT_color_subtable ******
	isGL_EXT_color_subtable = false;

	glColorSubTableEXT = 0;
	glCopyColorSubTableEXT = 0;

	// ****** GL_EXT_compiled_vertex_array ******
	isGL_EXT_compiled_vertex_array = false;

	glLockArraysEXT = 0;
	glUnlockArraysEXT = 0;

	// ****** GL_EXT_convolution ******
	isGL_EXT_convolution = false;

	glConvolutionFilter1DEXT = 0;
	glConvolutionFilter2DEXT = 0;
	glConvolutionParameterfEXT = 0;
	glConvolutionParameterfvEXT = 0;
	glConvolutionParameteriEXT = 0;
	glConvolutionParameterivEXT = 0;
	glCopyConvolutionFilter1DEXT = 0;
	glCopyConvolutionFilter2DEXT = 0;
	glGetConvolutionFilterEXT = 0;
	glGetConvolutionParameterfvEXT = 0;
	glGetConvolutionParameterivEXT = 0;
	glGetSeparableFilterEXT = 0;
	glSeparableFilter2DEXT = 0;

	// ****** GL_EXT_coordinate_frame ******
	isGL_EXT_coordinate_frame = false;

	glBinormal3bEXT = 0;
	glBinormal3bvEXT = 0;
	glBinormal3dEXT = 0;
	glBinormal3dvEXT = 0;
	glBinormal3fEXT = 0;
	glBinormal3fvEXT = 0;
	glBinormal3iEXT = 0;
	glBinormal3ivEXT = 0;
	glBinormal3sEXT = 0;
	glBinormal3svEXT = 0;
	glBinormalPointerEXT = 0;
	glTangent3bEXT = 0;
	glTangent3bvEXT = 0;
	glTangent3dEXT = 0;
	glTangent3dvEXT = 0;
	glTangent3fEXT = 0;
	glTangent3fvEXT = 0;
	glTangent3iEXT = 0;
	glTangent3ivEXT = 0;
	glTangent3sEXT = 0;
	glTangent3svEXT = 0;
	glTangentPointerEXT = 0;

	// ****** GL_EXT_copy_texture ******
	isGL_EXT_copy_texture = false;

	glCopyTexImage1DEXT = 0;
	glCopyTexImage2DEXT = 0;
	glCopyTexSubImage1DEXT = 0;
	glCopyTexSubImage2DEXT = 0;
	glCopyTexSubImage3DEXT = 0;

	// ****** GL_EXT_cull_vertex ******
	isGL_EXT_cull_vertex = false;

	glCullParameterdvEXT = 0;
	glCullParameterfvEXT = 0;

	// ****** GL_EXT_depth_bounds_test ******
	isGL_EXT_depth_bounds_test = false;

	glDepthBoundsEXT = 0;

	// ****** GL_EXT_direct_state_access ******
	isGL_EXT_direct_state_access = false;

	glBindMultiTextureEXT = 0;
	glCheckNamedFramebufferStatusEXT = 0;
	glClientAttribDefaultEXT = 0;
	glCompressedMultiTexImage1DEXT = 0;
	glCompressedMultiTexImage2DEXT = 0;
	glCompressedMultiTexImage3DEXT = 0;
	glCompressedMultiTexSubImage1DEXT = 0;
	glCompressedMultiTexSubImage2DEXT = 0;
	glCompressedMultiTexSubImage3DEXT = 0;
	glCompressedTextureImage1DEXT = 0;
	glCompressedTextureImage2DEXT = 0;
	glCompressedTextureImage3DEXT = 0;
	glCompressedTextureSubImage1DEXT = 0;
	glCompressedTextureSubImage2DEXT = 0;
	glCompressedTextureSubImage3DEXT = 0;
	glCopyMultiTexImage1DEXT = 0;
	glCopyMultiTexImage2DEXT = 0;
	glCopyMultiTexSubImage1DEXT = 0;
	glCopyMultiTexSubImage2DEXT = 0;
	glCopyMultiTexSubImage3DEXT = 0;
	glCopyTextureImage1DEXT = 0;
	glCopyTextureImage2DEXT = 0;
	glCopyTextureSubImage1DEXT = 0;
	glCopyTextureSubImage2DEXT = 0;
	glCopyTextureSubImage3DEXT = 0;
	glDisableClientStateIndexedEXT = 0;
	glEnableClientStateIndexedEXT = 0;
	glFlushMappedNamedBufferRangeEXT = 0;
	glFramebufferDrawBufferEXT = 0;
	glFramebufferDrawBuffersEXT = 0;
	glFramebufferReadBufferEXT = 0;
	glGenerateMultiTexMipmapEXT = 0;
	glGenerateTextureMipmapEXT = 0;
	glGetCompressedMultiTexImageEXT = 0;
	glGetCompressedTextureImageEXT = 0;
	glGetDoubleIndexedvEXT = 0;
	glGetFloatIndexedvEXT = 0;
	glGetFramebufferParameterivEXT = 0;
	glGetMultiTexEnvfvEXT = 0;
	glGetMultiTexEnvivEXT = 0;
	glGetMultiTexGendvEXT = 0;
	glGetMultiTexGenfvEXT = 0;
	glGetMultiTexGenivEXT = 0;
	glGetMultiTexImageEXT = 0;
	glGetMultiTexLevelParameterfvEXT = 0;
	glGetMultiTexLevelParameterivEXT = 0;
	glGetMultiTexParameterIivEXT = 0;
	glGetMultiTexParameterIuivEXT = 0;
	glGetMultiTexParameterfvEXT = 0;
	glGetMultiTexParameterivEXT = 0;
	glGetNamedBufferParameterivEXT = 0;
	glGetNamedBufferPointervEXT = 0;
	glGetNamedBufferSubDataEXT = 0;
	glGetNamedFramebufferAttachmentParameterivEXT = 0;
	glGetNamedProgramLocalParameterIivEXT = 0;
	glGetNamedProgramLocalParameterIuivEXT = 0;
	glGetNamedProgramLocalParameterdvEXT = 0;
	glGetNamedProgramLocalParameterfvEXT = 0;
	glGetNamedProgramStringEXT = 0;
	glGetNamedProgramivEXT = 0;
	glGetNamedRenderbufferParameterivEXT = 0;
	glGetPointerIndexedvEXT = 0;
	glGetTextureImageEXT = 0;
	glGetTextureLevelParameterfvEXT = 0;
	glGetTextureLevelParameterivEXT = 0;
	glGetTextureParameterIivEXT = 0;
	glGetTextureParameterIuivEXT = 0;
	glGetTextureParameterfvEXT = 0;
	glGetTextureParameterivEXT = 0;
	glMapNamedBufferEXT = 0;
	glMapNamedBufferRangeEXT = 0;
	glMatrixFrustumEXT = 0;
	glMatrixLoadIdentityEXT = 0;
	glMatrixLoadTransposedEXT = 0;
	glMatrixLoadTransposefEXT = 0;
	glMatrixLoaddEXT = 0;
	glMatrixLoadfEXT = 0;
	glMatrixMultTransposedEXT = 0;
	glMatrixMultTransposefEXT = 0;
	glMatrixMultdEXT = 0;
	glMatrixMultfEXT = 0;
	glMatrixOrthoEXT = 0;
	glMatrixPopEXT = 0;
	glMatrixPushEXT = 0;
	glMatrixRotatedEXT = 0;
	glMatrixRotatefEXT = 0;
	glMatrixScaledEXT = 0;
	glMatrixScalefEXT = 0;
	glMatrixTranslatedEXT = 0;
	glMatrixTranslatefEXT = 0;
	glMultiTexBufferEXT = 0;
	glMultiTexCoordPointerEXT = 0;
	glMultiTexEnvfEXT = 0;
	glMultiTexEnvfvEXT = 0;
	glMultiTexEnviEXT = 0;
	glMultiTexEnvivEXT = 0;
	glMultiTexGendEXT = 0;
	glMultiTexGendvEXT = 0;
	glMultiTexGenfEXT = 0;
	glMultiTexGenfvEXT = 0;
	glMultiTexGeniEXT = 0;
	glMultiTexGenivEXT = 0;
	glMultiTexImage1DEXT = 0;
	glMultiTexImage2DEXT = 0;
	glMultiTexImage3DEXT = 0;
	glMultiTexParameterIivEXT = 0;
	glMultiTexParameterIuivEXT = 0;
	glMultiTexParameterfEXT = 0;
	glMultiTexParameterfvEXT = 0;
	glMultiTexParameteriEXT = 0;
	glMultiTexParameterivEXT = 0;
	glMultiTexRenderbufferEXT = 0;
	glMultiTexSubImage1DEXT = 0;
	glMultiTexSubImage2DEXT = 0;
	glMultiTexSubImage3DEXT = 0;
	glNamedBufferDataEXT = 0;
	glNamedBufferSubDataEXT = 0;
	glNamedCopyBufferSubDataEXT = 0;
	glNamedFramebufferRenderbufferEXT = 0;
	glNamedFramebufferTexture1DEXT = 0;
	glNamedFramebufferTexture2DEXT = 0;
	glNamedFramebufferTexture3DEXT = 0;
	glNamedFramebufferTextureEXT = 0;
	glNamedFramebufferTextureFaceEXT = 0;
	glNamedFramebufferTextureLayerEXT = 0;
	glNamedProgramLocalParameter4dEXT = 0;
	glNamedProgramLocalParameter4dvEXT = 0;
	glNamedProgramLocalParameter4fEXT = 0;
	glNamedProgramLocalParameter4fvEXT = 0;
	glNamedProgramLocalParameterI4iEXT = 0;
	glNamedProgramLocalParameterI4ivEXT = 0;
	glNamedProgramLocalParameterI4uiEXT = 0;
	glNamedProgramLocalParameterI4uivEXT = 0;
	glNamedProgramLocalParameters4fvEXT = 0;
	glNamedProgramLocalParametersI4ivEXT = 0;
	glNamedProgramLocalParametersI4uivEXT = 0;
	glNamedProgramStringEXT = 0;
	glNamedRenderbufferStorageEXT = 0;
	glNamedRenderbufferStorageMultisampleCoverageEXT = 0;
	glNamedRenderbufferStorageMultisampleEXT = 0;
	glProgramUniform1dEXT = 0;
	glProgramUniform1dvEXT = 0;
	glProgramUniform1fEXT = 0;
	glProgramUniform1fvEXT = 0;
	glProgramUniform1iEXT = 0;
	glProgramUniform1ivEXT = 0;
	glProgramUniform1uiEXT = 0;
	glProgramUniform1uivEXT = 0;
	glProgramUniform2dEXT = 0;
	glProgramUniform2dvEXT = 0;
	glProgramUniform2fEXT = 0;
	glProgramUniform2fvEXT = 0;
	glProgramUniform2iEXT = 0;
	glProgramUniform2ivEXT = 0;
	glProgramUniform2uiEXT = 0;
	glProgramUniform2uivEXT = 0;
	glProgramUniform3dEXT = 0;
	glProgramUniform3dvEXT = 0;
	glProgramUniform3fEXT = 0;
	glProgramUniform3fvEXT = 0;
	glProgramUniform3iEXT = 0;
	glProgramUniform3ivEXT = 0;
	glProgramUniform3uiEXT = 0;
	glProgramUniform3uivEXT = 0;
	glProgramUniform4dEXT = 0;
	glProgramUniform4dvEXT = 0;
	glProgramUniform4fEXT = 0;
	glProgramUniform4fvEXT = 0;
	glProgramUniform4iEXT = 0;
	glProgramUniform4ivEXT = 0;
	glProgramUniform4uiEXT = 0;
	glProgramUniform4uivEXT = 0;
	glProgramUniformMatrix2dvEXT = 0;
	glProgramUniformMatrix2fvEXT = 0;
	glProgramUniformMatrix2x3dvEXT = 0;
	glProgramUniformMatrix2x3fvEXT = 0;
	glProgramUniformMatrix2x4dvEXT = 0;
	glProgramUniformMatrix2x4fvEXT = 0;
	glProgramUniformMatrix3dvEXT = 0;
	glProgramUniformMatrix3fvEXT = 0;
	glProgramUniformMatrix3x2dvEXT = 0;
	glProgramUniformMatrix3x2fvEXT = 0;
	glProgramUniformMatrix3x4dvEXT = 0;
	glProgramUniformMatrix3x4fvEXT = 0;
	glProgramUniformMatrix4dvEXT = 0;
	glProgramUniformMatrix4fvEXT = 0;
	glProgramUniformMatrix4x2dvEXT = 0;
	glProgramUniformMatrix4x2fvEXT = 0;
	glProgramUniformMatrix4x3dvEXT = 0;
	glProgramUniformMatrix4x3fvEXT = 0;
	glPushClientAttribDefaultEXT = 0;
	glTextureBufferEXT = 0;
	glTextureImage1DEXT = 0;
	glTextureImage2DEXT = 0;
	glTextureImage3DEXT = 0;
	glTextureParameterIivEXT = 0;
	glTextureParameterIuivEXT = 0;
	glTextureParameterfEXT = 0;
	glTextureParameterfvEXT = 0;
	glTextureParameteriEXT = 0;
	glTextureParameterivEXT = 0;
	glTextureRenderbufferEXT = 0;
	glTextureSubImage1DEXT = 0;
	glTextureSubImage2DEXT = 0;
	glTextureSubImage3DEXT = 0;
	glUnmapNamedBufferEXT = 0;

	// ****** GL_EXT_draw_buffers2 ******
	isGL_EXT_draw_buffers2 = false;

	glColorMaskIndexedEXT = 0;
	glDisableIndexedEXT = 0;
	glEnableIndexedEXT = 0;
	glGetBooleanIndexedvEXT = 0;
	glGetIntegerIndexedvEXT = 0;
	glIsEnabledIndexedEXT = 0;

	// ****** GL_EXT_draw_instanced ******
	isGL_EXT_draw_instanced = false;

	glDrawArraysInstancedEXT = 0;
	glDrawElementsInstancedEXT = 0;

	// ****** GL_EXT_draw_range_elements ******
	isGL_EXT_draw_range_elements = false;

	glDrawRangeElementsEXT = 0;

	// ****** GL_EXT_fog_coord ******
	isGL_EXT_fog_coord = false;

	glFogCoordPointerEXT = 0;
	glFogCoorddEXT = 0;
	glFogCoorddvEXT = 0;
	glFogCoordfEXT = 0;
	glFogCoordfvEXT = 0;

	// ****** GL_EXT_framebuffer_blit ******
	isGL_EXT_framebuffer_blit = false;

	glBlitFramebufferEXT = 0;

	// ****** GL_EXT_framebuffer_multisample ******
	isGL_EXT_framebuffer_multisample = false;

	glRenderbufferStorageMultisampleEXT = 0;

	// ****** GL_EXT_framebuffer_multisample_blit_scaled ******
	isGL_EXT_framebuffer_multisample_blit_scaled = false;

	// ****** GL_EXT_framebuffer_object ******
	isGL_EXT_framebuffer_object = false;

	glBindFramebufferEXT = 0;
	glBindRenderbufferEXT = 0;
	glCheckFramebufferStatusEXT = 0;
	glDeleteFramebuffersEXT = 0;
	glDeleteRenderbuffersEXT = 0;
	glFramebufferRenderbufferEXT = 0;
	glFramebufferTexture1DEXT = 0;
	glFramebufferTexture2DEXT = 0;
	glFramebufferTexture3DEXT = 0;
	glGenFramebuffersEXT = 0;
	glGenRenderbuffersEXT = 0;
	glGenerateMipmapEXT = 0;
	glGetFramebufferAttachmentParameterivEXT = 0;
	glGetRenderbufferParameterivEXT = 0;
	glIsFramebufferEXT = 0;
	glIsRenderbufferEXT = 0;
	glRenderbufferStorageEXT = 0;

	// ****** GL_EXT_framebuffer_sRGB ******
	isGL_EXT_framebuffer_sRGB = false;

	// ****** GL_EXT_geometry_shader4 ******
	isGL_EXT_geometry_shader4 = false;

	glProgramParameteriEXT = 0;

	// ****** GL_EXT_gpu_program_parameters ******
	isGL_EXT_gpu_program_parameters = false;

	glProgramEnvParameters4fvEXT = 0;
	glProgramLocalParameters4fvEXT = 0;

	// ****** GL_EXT_gpu_shader4 ******
	isGL_EXT_gpu_shader4 = false;

	glBindFragDataLocationEXT = 0;
	glGetFragDataLocationEXT = 0;
	glGetUniformuivEXT = 0;
	glUniform1uiEXT = 0;
	glUniform1uivEXT = 0;
	glUniform2uiEXT = 0;
	glUniform2uivEXT = 0;
	glUniform3uiEXT = 0;
	glUniform3uivEXT = 0;
	glUniform4uiEXT = 0;
	glUniform4uivEXT = 0;

	// ****** GL_EXT_histogram ******
	isGL_EXT_histogram = false;

	glGetHistogramEXT = 0;
	glGetHistogramParameterfvEXT = 0;
	glGetHistogramParameterivEXT = 0;
	glGetMinmaxEXT = 0;
	glGetMinmaxParameterfvEXT = 0;
	glGetMinmaxParameterivEXT = 0;
	glHistogramEXT = 0;
	glMinmaxEXT = 0;
	glResetHistogramEXT = 0;
	glResetMinmaxEXT = 0;

	// ****** GL_EXT_index_array_formats ******
	isGL_EXT_index_array_formats = false;

	// ****** GL_EXT_index_func ******
	isGL_EXT_index_func = false;

	glIndexFuncEXT = 0;

	// ****** GL_EXT_index_material ******
	isGL_EXT_index_material = false;

	glIndexMaterialEXT = 0;

	// ****** GL_EXT_index_texture ******
	isGL_EXT_index_texture = false;

	// ****** GL_EXT_light_texture ******
	isGL_EXT_light_texture = false;

	glApplyTextureEXT = 0;
	glTextureLightEXT = 0;
	glTextureMaterialEXT = 0;

	// ****** GL_EXT_misc_attribute ******
	isGL_EXT_misc_attribute = false;

	// ****** GL_EXT_multi_draw_arrays ******
	isGL_EXT_multi_draw_arrays = false;

	glMultiDrawArraysEXT = 0;
	glMultiDrawElementsEXT = 0;

	// ****** GL_EXT_multisample ******
	isGL_EXT_multisample = false;

	glSampleMaskEXT = 0;
	glSamplePatternEXT = 0;

	// ****** GL_EXT_packed_depth_stencil ******
	isGL_EXT_packed_depth_stencil = false;

	// ****** GL_EXT_packed_float ******
	isGL_EXT_packed_float = false;

	// ****** GL_EXT_packed_pixels ******
	isGL_EXT_packed_pixels = false;

	// ****** GL_EXT_paletted_texture ******
	isGL_EXT_paletted_texture = false;

	glColorTableEXT = 0;
	glGetColorTableEXT = 0;
	glGetColorTableParameterfvEXT = 0;
	glGetColorTableParameterivEXT = 0;

	// ****** GL_EXT_pixel_buffer_object ******
	isGL_EXT_pixel_buffer_object = false;

	// ****** GL_EXT_pixel_transform ******
	isGL_EXT_pixel_transform = false;

	glGetPixelTransformParameterfvEXT = 0;
	glGetPixelTransformParameterivEXT = 0;
	glPixelTransformParameterfEXT = 0;
	glPixelTransformParameterfvEXT = 0;
	glPixelTransformParameteriEXT = 0;
	glPixelTransformParameterivEXT = 0;

	// ****** GL_EXT_pixel_transform_color_table ******
	isGL_EXT_pixel_transform_color_table = false;

	// ****** GL_EXT_point_parameters ******
	isGL_EXT_point_parameters = false;

	glPointParameterfEXT = 0;
	glPointParameterfvEXT = 0;

	// ****** GL_EXT_polygon_offset ******
	isGL_EXT_polygon_offset = false;

	glPolygonOffsetEXT = 0;

	// ****** GL_EXT_provoking_vertex ******
	isGL_EXT_provoking_vertex = false;

	glProvokingVertexEXT = 0;

	// ****** GL_EXT_rescale_normal ******
	isGL_EXT_rescale_normal = false;

	// ****** GL_EXT_secondary_color ******
	isGL_EXT_secondary_color = false;

	glSecondaryColor3bEXT = 0;
	glSecondaryColor3bvEXT = 0;
	glSecondaryColor3dEXT = 0;
	glSecondaryColor3dvEXT = 0;
	glSecondaryColor3fEXT = 0;
	glSecondaryColor3fvEXT = 0;
	glSecondaryColor3iEXT = 0;
	glSecondaryColor3ivEXT = 0;
	glSecondaryColor3sEXT = 0;
	glSecondaryColor3svEXT = 0;
	glSecondaryColor3ubEXT = 0;
	glSecondaryColor3ubvEXT = 0;
	glSecondaryColor3uiEXT = 0;
	glSecondaryColor3uivEXT = 0;
	glSecondaryColor3usEXT = 0;
	glSecondaryColor3usvEXT = 0;
	glSecondaryColorPointerEXT = 0;

	// ****** GL_EXT_separate_shader_objects ******
	isGL_EXT_separate_shader_objects = false;

	glActiveProgramEXT = 0;
	glCreateShaderProgramEXT = 0;
	glUseShaderProgramEXT = 0;

	// ****** GL_EXT_separate_specular_color ******
	isGL_EXT_separate_specular_color = false;

	// ****** GL_EXT_shader_image_load_store ******
	isGL_EXT_shader_image_load_store = false;

	glBindImageTextureEXT = 0;
	glMemoryBarrierEXT = 0;

	// ****** GL_EXT_shadow_funcs ******
	isGL_EXT_shadow_funcs = false;

	// ****** GL_EXT_shared_texture_palette ******
	isGL_EXT_shared_texture_palette = false;

	// ****** GL_EXT_stencil_clear_tag ******
	isGL_EXT_stencil_clear_tag = false;

	glStencilClearTagEXT = 0;

	// ****** GL_EXT_stencil_two_side ******
	isGL_EXT_stencil_two_side = false;

	glActiveStencilFaceEXT = 0;

	// ****** GL_EXT_stencil_wrap ******
	isGL_EXT_stencil_wrap = false;

	// ****** GL_EXT_subtexture ******
	isGL_EXT_subtexture = false;

	glTexSubImage1DEXT = 0;
	glTexSubImage2DEXT = 0;

	// ****** GL_EXT_texture ******
	isGL_EXT_texture = false;

	// ****** GL_EXT_texture3D ******
	isGL_EXT_texture3D = false;

	glTexImage3DEXT = 0;
	glTexSubImage3DEXT = 0;

	// ****** GL_EXT_texture_array ******
	isGL_EXT_texture_array = false;

	// ****** GL_EXT_texture_buffer_object ******
	isGL_EXT_texture_buffer_object = false;

	glTexBufferEXT = 0;

	// ****** GL_EXT_texture_compression_latc ******
	isGL_EXT_texture_compression_latc = false;

	// ****** GL_EXT_texture_compression_rgtc ******
	isGL_EXT_texture_compression_rgtc = false;

	// ****** GL_EXT_texture_compression_s3tc ******
	isGL_EXT_texture_compression_s3tc = false;

	// ****** GL_EXT_texture_cube_map ******
	isGL_EXT_texture_cube_map = false;

	// ****** GL_EXT_texture_env_add ******
	isGL_EXT_texture_env_add = false;

	// ****** GL_EXT_texture_env_combine ******
	isGL_EXT_texture_env_combine = false;

	// ****** GL_EXT_texture_env_dot3 ******
	isGL_EXT_texture_env_dot3 = false;

	// ****** GL_EXT_texture_filter_anisotropic ******
	isGL_EXT_texture_filter_anisotropic = false;

	// ****** GL_EXT_texture_integer ******
	isGL_EXT_texture_integer = false;

	glClearColorIiEXT = 0;
	glClearColorIuiEXT = 0;
	glGetTexParameterIivEXT = 0;
	glGetTexParameterIuivEXT = 0;
	glTexParameterIivEXT = 0;
	glTexParameterIuivEXT = 0;

	// ****** GL_EXT_texture_lod_bias ******
	isGL_EXT_texture_lod_bias = false;

	// ****** GL_EXT_texture_mirror_clamp ******
	isGL_EXT_texture_mirror_clamp = false;

	// ****** GL_EXT_texture_object ******
	isGL_EXT_texture_object = false;

	glAreTexturesResidentEXT = 0;
	glBindTextureEXT = 0;
	glDeleteTexturesEXT = 0;
	glGenTexturesEXT = 0;
	glIsTextureEXT = 0;
	glPrioritizeTexturesEXT = 0;

	// ****** GL_EXT_texture_perturb_normal ******
	isGL_EXT_texture_perturb_normal = false;

	glTextureNormalEXT = 0;

	// ****** GL_EXT_texture_sRGB ******
	isGL_EXT_texture_sRGB = false;

	// ****** GL_EXT_texture_sRGB_decode ******
	isGL_EXT_texture_sRGB_decode = false;

	// ****** GL_EXT_texture_shared_exponent ******
	isGL_EXT_texture_shared_exponent = false;

	// ****** GL_EXT_texture_snorm ******
	isGL_EXT_texture_snorm = false;

	// ****** GL_EXT_texture_swizzle ******
	isGL_EXT_texture_swizzle = false;

	// ****** GL_EXT_timer_query ******
	isGL_EXT_timer_query = false;

	glGetQueryObjecti64vEXT = 0;
	glGetQueryObjectui64vEXT = 0;

	// ****** GL_EXT_transform_feedback ******
	isGL_EXT_transform_feedback = false;

	glBeginTransformFeedbackEXT = 0;
	glBindBufferBaseEXT = 0;
	glBindBufferOffsetEXT = 0;
	glBindBufferRangeEXT = 0;
	glEndTransformFeedbackEXT = 0;
	glGetTransformFeedbackVaryingEXT = 0;
	glTransformFeedbackVaryingsEXT = 0;

	// ****** GL_EXT_vertex_array ******
	isGL_EXT_vertex_array = false;

	glArrayElementEXT = 0;
	glColorPointerEXT = 0;
	glDrawArraysEXT = 0;
	glEdgeFlagPointerEXT = 0;
	glGetPointervEXT = 0;
	glIndexPointerEXT = 0;
	glNormalPointerEXT = 0;
	glTexCoordPointerEXT = 0;
	glVertexPointerEXT = 0;

	// ****** GL_EXT_vertex_array_bgra ******
	isGL_EXT_vertex_array_bgra = false;

	// ****** GL_EXT_vertex_attrib_64bit ******
	isGL_EXT_vertex_attrib_64bit = false;

	glGetVertexAttribLdvEXT = 0;
	glVertexArrayVertexAttribLOffsetEXT = 0;
	glVertexAttribL1dEXT = 0;
	glVertexAttribL1dvEXT = 0;
	glVertexAttribL2dEXT = 0;
	glVertexAttribL2dvEXT = 0;
	glVertexAttribL3dEXT = 0;
	glVertexAttribL3dvEXT = 0;
	glVertexAttribL4dEXT = 0;
	glVertexAttribL4dvEXT = 0;
	glVertexAttribLPointerEXT = 0;

	// ****** GL_EXT_vertex_shader ******
	isGL_EXT_vertex_shader = false;

	glBeginVertexShaderEXT = 0;
	glBindLightParameterEXT = 0;
	glBindMaterialParameterEXT = 0;
	glBindParameterEXT = 0;
	glBindTexGenParameterEXT = 0;
	glBindTextureUnitParameterEXT = 0;
	glBindVertexShaderEXT = 0;
	glDeleteVertexShaderEXT = 0;
	glDisableVariantClientStateEXT = 0;
	glEnableVariantClientStateEXT = 0;
	glEndVertexShaderEXT = 0;
	glExtractComponentEXT = 0;
	glGenSymbolsEXT = 0;
	glGenVertexShadersEXT = 0;
	glGetInvariantBooleanvEXT = 0;
	glGetInvariantFloatvEXT = 0;
	glGetInvariantIntegervEXT = 0;
	glGetLocalConstantBooleanvEXT = 0;
	glGetLocalConstantFloatvEXT = 0;
	glGetLocalConstantIntegervEXT = 0;
	glGetVariantBooleanvEXT = 0;
	glGetVariantFloatvEXT = 0;
	glGetVariantIntegervEXT = 0;
	glGetVariantPointervEXT = 0;
	glInsertComponentEXT = 0;
	glIsVariantEnabledEXT = 0;
	glSetInvariantEXT = 0;
	glSetLocalConstantEXT = 0;
	glShaderOp1EXT = 0;
	glShaderOp2EXT = 0;
	glShaderOp3EXT = 0;
	glSwizzleEXT = 0;
	glVariantPointerEXT = 0;
	glVariantbvEXT = 0;
	glVariantdvEXT = 0;
	glVariantfvEXT = 0;
	glVariantivEXT = 0;
	glVariantsvEXT = 0;
	glVariantubvEXT = 0;
	glVariantuivEXT = 0;
	glVariantusvEXT = 0;
	glWriteMaskEXT = 0;

	// ****** GL_EXT_vertex_weighting ******
	isGL_EXT_vertex_weighting = false;

	glVertexWeightPointerEXT = 0;
	glVertexWeightfEXT = 0;
	glVertexWeightfvEXT = 0;

	// ****** GL_EXT_x11_sync_object ******
	isGL_EXT_x11_sync_object = false;

	glImportSyncEXT = 0;

	// ****** GL_FfdMaskSGIX ******
	isGL_FfdMaskSGIX = false;

	// ****** GL_GREMEDY_frame_terminator ******
	isGL_GREMEDY_frame_terminator = false;

	glFrameTerminatorGREMEDY = 0;

	// ****** GL_GREMEDY_string_marker ******
	isGL_GREMEDY_string_marker = false;

	glStringMarkerGREMEDY = 0;

	// ****** GL_HP_convolution_border_modes ******
	isGL_HP_convolution_border_modes = false;

	// ****** GL_HP_image_transform ******
	isGL_HP_image_transform = false;

	glGetImageTransformParameterfvHP = 0;
	glGetImageTransformParameterivHP = 0;
	glImageTransformParameterfHP = 0;
	glImageTransformParameterfvHP = 0;
	glImageTransformParameteriHP = 0;
	glImageTransformParameterivHP = 0;

	// ****** GL_HP_occlusion_test ******
	isGL_HP_occlusion_test = false;

	// ****** GL_HP_texture_lighting ******
	isGL_HP_texture_lighting = false;

	// ****** GL_IBM_cull_vertex ******
	isGL_IBM_cull_vertex = false;

	// ****** GL_IBM_multimode_draw_arrays ******
	isGL_IBM_multimode_draw_arrays = false;

	glMultiModeDrawArraysIBM = 0;
	glMultiModeDrawElementsIBM = 0;

	// ****** GL_IBM_rasterpos_clip ******
	isGL_IBM_rasterpos_clip = false;

	// ****** GL_IBM_texture_mirrored_repeat ******
	isGL_IBM_texture_mirrored_repeat = false;

	// ****** GL_IBM_vertex_array_lists ******
	isGL_IBM_vertex_array_lists = false;

	glColorPointerListIBM = 0;
	glEdgeFlagPointerListIBM = 0;
	glFogCoordPointerListIBM = 0;
	glIndexPointerListIBM = 0;
	glNormalPointerListIBM = 0;
	glSecondaryColorPointerListIBM = 0;
	glTexCoordPointerListIBM = 0;
	glVertexPointerListIBM = 0;

	// ****** GL_INGR_blend_func_separate ******
	isGL_INGR_blend_func_separate = false;

	glBlendFuncSeparateINGR = 0;

	// ****** GL_INGR_color_clamp ******
	isGL_INGR_color_clamp = false;

	// ****** GL_INGR_interlace_read ******
	isGL_INGR_interlace_read = false;

	// ****** GL_INGR_palette_buffer ******
	isGL_INGR_palette_buffer = false;

	// ****** GL_INTEL_map_texture ******
	isGL_INTEL_map_texture = false;

	glMapTexture2DINTEL = 0;
	glSyncTextureINTEL = 0;
	glUnmapTexture2DINTEL = 0;

	// ****** GL_INTEL_parallel_arrays ******
	isGL_INTEL_parallel_arrays = false;

	glColorPointervINTEL = 0;
	glNormalPointervINTEL = 0;
	glTexCoordPointervINTEL = 0;
	glVertexPointervINTEL = 0;

	// ****** GL_INTEL_texture_scissor ******
	isGL_INTEL_texture_scissor = false;

	// ****** GL_KHR_debug ******
	isGL_KHR_debug = false;

	glDebugMessageCallback = 0;
	glDebugMessageControl = 0;
	glDebugMessageInsert = 0;
	glGetDebugMessageLog = 0;
	glGetObjectLabel = 0;
	glGetObjectPtrLabel = 0;
	glObjectLabel = 0;
	glObjectPtrLabel = 0;
	glPopDebugGroup = 0;
	glPushDebugGroup = 0;

	// ****** GL_KHR_texture_compression_astc_ldr ******
	isGL_KHR_texture_compression_astc_ldr = false;

	// ****** GL_MESAX_texture_stack ******
	isGL_MESAX_texture_stack = false;

	// ****** GL_MESA_pack_invert ******
	isGL_MESA_pack_invert = false;

	// ****** GL_MESA_resize_buffers ******
	isGL_MESA_resize_buffers = false;

	glResizeBuffersMESA = 0;

	// ****** GL_MESA_window_pos ******
	isGL_MESA_window_pos = false;

	glWindowPos2dMESA = 0;
	glWindowPos2dvMESA = 0;
	glWindowPos2fMESA = 0;
	glWindowPos2fvMESA = 0;
	glWindowPos2iMESA = 0;
	glWindowPos2ivMESA = 0;
	glWindowPos2sMESA = 0;
	glWindowPos2svMESA = 0;
	glWindowPos3dMESA = 0;
	glWindowPos3dvMESA = 0;
	glWindowPos3fMESA = 0;
	glWindowPos3fvMESA = 0;
	glWindowPos3iMESA = 0;
	glWindowPos3ivMESA = 0;
	glWindowPos3sMESA = 0;
	glWindowPos3svMESA = 0;
	glWindowPos4dMESA = 0;
	glWindowPos4dvMESA = 0;
	glWindowPos4fMESA = 0;
	glWindowPos4fvMESA = 0;
	glWindowPos4iMESA = 0;
	glWindowPos4ivMESA = 0;
	glWindowPos4sMESA = 0;
	glWindowPos4svMESA = 0;

	// ****** GL_MESA_ycbcr_texture ******
	isGL_MESA_ycbcr_texture = false;

	// ****** GL_NVX_conditional_render ******
	isGL_NVX_conditional_render = false;

	glBeginConditionalRenderNVX = 0;
	glEndConditionalRenderNVX = 0;

	// ****** GL_NV_bindless_texture ******
	isGL_NV_bindless_texture = false;

	glGetImageHandleNV = 0;
	glGetTextureHandleNV = 0;
	glGetTextureSamplerHandleNV = 0;
	glIsImageHandleResidentNV = 0;
	glIsTextureHandleResidentNV = 0;
	glMakeImageHandleNonResidentNV = 0;
	glMakeImageHandleResidentNV = 0;
	glMakeTextureHandleNonResidentNV = 0;
	glMakeTextureHandleResidentNV = 0;
	glProgramUniformHandleui64NV = 0;
	glProgramUniformHandleui64vNV = 0;
	glUniformHandleui64NV = 0;
	glUniformHandleui64vNV = 0;

	// ****** GL_NV_blend_square ******
	isGL_NV_blend_square = false;

	// ****** GL_NV_compute_program5 ******
	isGL_NV_compute_program5 = false;

	// ****** GL_NV_conditional_render ******
	isGL_NV_conditional_render = false;

	glBeginConditionalRenderNV = 0;
	glEndConditionalRenderNV = 0;

	// ****** GL_NV_copy_depth_to_color ******
	isGL_NV_copy_depth_to_color = false;

	// ****** GL_NV_copy_image ******
	isGL_NV_copy_image = false;

	glCopyImageSubDataNV = 0;

	// ****** GL_NV_deep_texture3D ******
	isGL_NV_deep_texture3D = false;

	// ****** GL_NV_depth_buffer_float ******
	isGL_NV_depth_buffer_float = false;

	glClearDepthdNV = 0;
	glDepthBoundsdNV = 0;
	glDepthRangedNV = 0;

	// ****** GL_NV_depth_clamp ******
	isGL_NV_depth_clamp = false;

	// ****** GL_NV_draw_texture ******
	isGL_NV_draw_texture = false;

	glDrawTextureNV = 0;

	// ****** GL_NV_evaluators ******
	isGL_NV_evaluators = false;

	glEvalMapsNV = 0;
	glGetMapAttribParameterfvNV = 0;
	glGetMapAttribParameterivNV = 0;
	glGetMapControlPointsNV = 0;
	glGetMapParameterfvNV = 0;
	glGetMapParameterivNV = 0;
	glMapControlPointsNV = 0;
	glMapParameterfvNV = 0;
	glMapParameterivNV = 0;

	// ****** GL_NV_explicit_multisample ******
	isGL_NV_explicit_multisample = false;

	glGetMultisamplefvNV = 0;
	glSampleMaskIndexedNV = 0;
	glTexRenderbufferNV = 0;

	// ****** GL_NV_fence ******
	isGL_NV_fence = false;

	glDeleteFencesNV = 0;
	glFinishFenceNV = 0;
	glGenFencesNV = 0;
	glGetFenceivNV = 0;
	glIsFenceNV = 0;
	glSetFenceNV = 0;
	glTestFenceNV = 0;

	// ****** GL_NV_float_buffer ******
	isGL_NV_float_buffer = false;

	// ****** GL_NV_fog_distance ******
	isGL_NV_fog_distance = false;

	// ****** GL_NV_fragment_program ******
	isGL_NV_fragment_program = false;

	glGetProgramNamedParameterdvNV = 0;
	glGetProgramNamedParameterfvNV = 0;
	glProgramNamedParameter4dNV = 0;
	glProgramNamedParameter4dvNV = 0;
	glProgramNamedParameter4fNV = 0;
	glProgramNamedParameter4fvNV = 0;

	// ****** GL_NV_fragment_program2 ******
	isGL_NV_fragment_program2 = false;

	// ****** GL_NV_fragment_program4 ******
	isGL_NV_fragment_program4 = false;

	// ****** GL_NV_fragment_program_option ******
	isGL_NV_fragment_program_option = false;

	// ****** GL_NV_framebuffer_multisample_coverage ******
	isGL_NV_framebuffer_multisample_coverage = false;

	glRenderbufferStorageMultisampleCoverageNV = 0;

	// ****** GL_NV_geometry_program4 ******
	isGL_NV_geometry_program4 = false;

	glFramebufferTextureEXT = 0;
	glFramebufferTextureFaceEXT = 0;
	glFramebufferTextureLayerEXT = 0;
	glProgramVertexLimitNV = 0;

	// ****** GL_NV_geometry_shader4 ******
	isGL_NV_geometry_shader4 = false;

	// ****** GL_NV_gpu_program4 ******
	isGL_NV_gpu_program4 = false;

	glGetProgramEnvParameterIivNV = 0;
	glGetProgramEnvParameterIuivNV = 0;
	glGetProgramLocalParameterIivNV = 0;
	glGetProgramLocalParameterIuivNV = 0;
	glProgramEnvParameterI4iNV = 0;
	glProgramEnvParameterI4ivNV = 0;
	glProgramEnvParameterI4uiNV = 0;
	glProgramEnvParameterI4uivNV = 0;
	glProgramEnvParametersI4ivNV = 0;
	glProgramEnvParametersI4uivNV = 0;
	glProgramLocalParameterI4iNV = 0;
	glProgramLocalParameterI4ivNV = 0;
	glProgramLocalParameterI4uiNV = 0;
	glProgramLocalParameterI4uivNV = 0;
	glProgramLocalParametersI4ivNV = 0;
	glProgramLocalParametersI4uivNV = 0;

	// ****** GL_NV_gpu_program5 ******
	isGL_NV_gpu_program5 = false;

	glGetProgramSubroutineParameteruivNV = 0;
	glProgramSubroutineParametersuivNV = 0;

	// ****** GL_NV_gpu_shader5 ******
	isGL_NV_gpu_shader5 = false;

	glGetUniformi64vNV = 0;
	glProgramUniform1i64NV = 0;
	glProgramUniform1i64vNV = 0;
	glProgramUniform1ui64NV = 0;
	glProgramUniform1ui64vNV = 0;
	glProgramUniform2i64NV = 0;
	glProgramUniform2i64vNV = 0;
	glProgramUniform2ui64NV = 0;
	glProgramUniform2ui64vNV = 0;
	glProgramUniform3i64NV = 0;
	glProgramUniform3i64vNV = 0;
	glProgramUniform3ui64NV = 0;
	glProgramUniform3ui64vNV = 0;
	glProgramUniform4i64NV = 0;
	glProgramUniform4i64vNV = 0;
	glProgramUniform4ui64NV = 0;
	glProgramUniform4ui64vNV = 0;
	glUniform1i64NV = 0;
	glUniform1i64vNV = 0;
	glUniform1ui64NV = 0;
	glUniform1ui64vNV = 0;
	glUniform2i64NV = 0;
	glUniform2i64vNV = 0;
	glUniform2ui64NV = 0;
	glUniform2ui64vNV = 0;
	glUniform3i64NV = 0;
	glUniform3i64vNV = 0;
	glUniform3ui64NV = 0;
	glUniform3ui64vNV = 0;
	glUniform4i64NV = 0;
	glUniform4i64vNV = 0;
	glUniform4ui64NV = 0;
	glUniform4ui64vNV = 0;

	// ****** GL_NV_half_float ******
	isGL_NV_half_float = false;

	glColor3hNV = 0;
	glColor3hvNV = 0;
	glColor4hNV = 0;
	glColor4hvNV = 0;
	glFogCoordhNV = 0;
	glFogCoordhvNV = 0;
	glMultiTexCoord1hNV = 0;
	glMultiTexCoord1hvNV = 0;
	glMultiTexCoord2hNV = 0;
	glMultiTexCoord2hvNV = 0;
	glMultiTexCoord3hNV = 0;
	glMultiTexCoord3hvNV = 0;
	glMultiTexCoord4hNV = 0;
	glMultiTexCoord4hvNV = 0;
	glNormal3hNV = 0;
	glNormal3hvNV = 0;
	glSecondaryColor3hNV = 0;
	glSecondaryColor3hvNV = 0;
	glTexCoord1hNV = 0;
	glTexCoord1hvNV = 0;
	glTexCoord2hNV = 0;
	glTexCoord2hvNV = 0;
	glTexCoord3hNV = 0;
	glTexCoord3hvNV = 0;
	glTexCoord4hNV = 0;
	glTexCoord4hvNV = 0;
	glVertex2hNV = 0;
	glVertex2hvNV = 0;
	glVertex3hNV = 0;
	glVertex3hvNV = 0;
	glVertex4hNV = 0;
	glVertex4hvNV = 0;
	glVertexAttrib1hNV = 0;
	glVertexAttrib1hvNV = 0;
	glVertexAttrib2hNV = 0;
	glVertexAttrib2hvNV = 0;
	glVertexAttrib3hNV = 0;
	glVertexAttrib3hvNV = 0;
	glVertexAttrib4hNV = 0;
	glVertexAttrib4hvNV = 0;
	glVertexAttribs1hvNV = 0;
	glVertexAttribs2hvNV = 0;
	glVertexAttribs3hvNV = 0;
	glVertexAttribs4hvNV = 0;
	glVertexWeighthNV = 0;
	glVertexWeighthvNV = 0;

	// ****** GL_NV_light_max_exponent ******
	isGL_NV_light_max_exponent = false;

	// ****** GL_NV_multisample_coverage ******
	isGL_NV_multisample_coverage = false;

	// ****** GL_NV_multisample_filter_hint ******
	isGL_NV_multisample_filter_hint = false;

	// ****** GL_NV_occlusion_query ******
	isGL_NV_occlusion_query = false;

	glBeginOcclusionQueryNV = 0;
	glDeleteOcclusionQueriesNV = 0;
	glEndOcclusionQueryNV = 0;
	glGenOcclusionQueriesNV = 0;
	glGetOcclusionQueryivNV = 0;
	glGetOcclusionQueryuivNV = 0;
	glIsOcclusionQueryNV = 0;

	// ****** GL_NV_packed_depth_stencil ******
	isGL_NV_packed_depth_stencil = false;

	// ****** GL_NV_parameter_buffer_object ******
	isGL_NV_parameter_buffer_object = false;

	glProgramBufferParametersIivNV = 0;
	glProgramBufferParametersIuivNV = 0;
	glProgramBufferParametersfvNV = 0;

	// ****** GL_NV_parameter_buffer_object2 ******
	isGL_NV_parameter_buffer_object2 = false;

	// ****** GL_NV_path_rendering ******
	isGL_NV_path_rendering = false;

	glCopyPathNV = 0;
	glCoverFillPathInstancedNV = 0;
	glCoverFillPathNV = 0;
	glCoverStrokePathInstancedNV = 0;
	glCoverStrokePathNV = 0;
	glDeletePathsNV = 0;
	glGenPathsNV = 0;
	glGetPathColorGenfvNV = 0;
	glGetPathColorGenivNV = 0;
	glGetPathCommandsNV = 0;
	glGetPathCoordsNV = 0;
	glGetPathDashArrayNV = 0;
	glGetPathLengthNV = 0;
	glGetPathMetricRangeNV = 0;
	glGetPathMetricsNV = 0;
	glGetPathParameterfvNV = 0;
	glGetPathParameterivNV = 0;
	glGetPathSpacingNV = 0;
	glGetPathTexGenfvNV = 0;
	glGetPathTexGenivNV = 0;
	glInterpolatePathsNV = 0;
	glIsPathNV = 0;
	glIsPointInFillPathNV = 0;
	glIsPointInStrokePathNV = 0;
	glPathColorGenNV = 0;
	glPathCommandsNV = 0;
	glPathCoordsNV = 0;
	glPathCoverDepthFuncNV = 0;
	glPathDashArrayNV = 0;
	glPathFogGenNV = 0;
	glPathGlyphRangeNV = 0;
	glPathGlyphsNV = 0;
	glPathParameterfNV = 0;
	glPathParameterfvNV = 0;
	glPathParameteriNV = 0;
	glPathParameterivNV = 0;
	glPathStencilDepthOffsetNV = 0;
	glPathStencilFuncNV = 0;
	glPathStringNV = 0;
	glPathSubCommandsNV = 0;
	glPathSubCoordsNV = 0;
	glPathTexGenNV = 0;
	glPointAlongPathNV = 0;
	glStencilFillPathInstancedNV = 0;
	glStencilFillPathNV = 0;
	glStencilStrokePathInstancedNV = 0;
	glStencilStrokePathNV = 0;
	glTransformPathNV = 0;
	glWeightPathsNV = 0;

	// ****** GL_NV_pixel_data_range ******
	isGL_NV_pixel_data_range = false;

	glFlushPixelDataRangeNV = 0;
	glPixelDataRangeNV = 0;

	// ****** GL_NV_point_sprite ******
	isGL_NV_point_sprite = false;

	glPointParameteriNV = 0;
	glPointParameterivNV = 0;

	// ****** GL_NV_present_video ******
	isGL_NV_present_video = false;

	glGetVideoi64vNV = 0;
	glGetVideoivNV = 0;
	glGetVideoui64vNV = 0;
	glGetVideouivNV = 0;
	glPresentFrameDualFillNV = 0;
	glPresentFrameKeyedNV = 0;

	// ****** GL_NV_primitive_restart ******
	isGL_NV_primitive_restart = false;

	glPrimitiveRestartIndexNV = 0;
	glPrimitiveRestartNV = 0;

	// ****** GL_NV_register_combiners ******
	isGL_NV_register_combiners = false;

	glCombinerInputNV = 0;
	glCombinerOutputNV = 0;
	glCombinerParameterfNV = 0;
	glCombinerParameterfvNV = 0;
	glCombinerParameteriNV = 0;
	glCombinerParameterivNV = 0;
	glFinalCombinerInputNV = 0;
	glGetCombinerInputParameterfvNV = 0;
	glGetCombinerInputParameterivNV = 0;
	glGetCombinerOutputParameterfvNV = 0;
	glGetCombinerOutputParameterivNV = 0;
	glGetFinalCombinerInputParameterfvNV = 0;
	glGetFinalCombinerInputParameterivNV = 0;

	// ****** GL_NV_register_combiners2 ******
	isGL_NV_register_combiners2 = false;

	glCombinerStageParameterfvNV = 0;
	glGetCombinerStageParameterfvNV = 0;

	// ****** GL_NV_shader_atomic_counters ******
	isGL_NV_shader_atomic_counters = false;

	// ****** GL_NV_shader_atomic_float ******
	isGL_NV_shader_atomic_float = false;

	// ****** GL_NV_shader_buffer_load ******
	isGL_NV_shader_buffer_load = false;

	glGetBufferParameterui64vNV = 0;
	glGetIntegerui64vNV = 0;
	glGetNamedBufferParameterui64vNV = 0;
	glGetUniformui64vNV = 0;
	glIsBufferResidentNV = 0;
	glIsNamedBufferResidentNV = 0;
	glMakeBufferNonResidentNV = 0;
	glMakeBufferResidentNV = 0;
	glMakeNamedBufferNonResidentNV = 0;
	glMakeNamedBufferResidentNV = 0;
	glProgramUniformui64NV = 0;
	glProgramUniformui64vNV = 0;
	glUniformui64NV = 0;
	glUniformui64vNV = 0;

	// ****** GL_NV_shader_buffer_store ******
	isGL_NV_shader_buffer_store = false;

	// ****** GL_NV_shader_storage_buffer_object ******
	isGL_NV_shader_storage_buffer_object = false;

	// ****** GL_NV_tessellation_program5 ******
	isGL_NV_tessellation_program5 = false;

	// ****** GL_NV_texgen_emboss ******
	isGL_NV_texgen_emboss = false;

	// ****** GL_NV_texgen_reflection ******
	isGL_NV_texgen_reflection = false;

	// ****** GL_NV_texture_barrier ******
	isGL_NV_texture_barrier = false;

	glTextureBarrierNV = 0;

	// ****** GL_NV_texture_compression_vtc ******
	isGL_NV_texture_compression_vtc = false;

	// ****** GL_NV_texture_env_combine4 ******
	isGL_NV_texture_env_combine4 = false;

	// ****** GL_NV_texture_expand_normal ******
	isGL_NV_texture_expand_normal = false;

	// ****** GL_NV_texture_multisample ******
	isGL_NV_texture_multisample = false;

	glTexImage2DMultisampleCoverageNV = 0;
	glTexImage3DMultisampleCoverageNV = 0;
	glTextureImage2DMultisampleCoverageNV = 0;
	glTextureImage2DMultisampleNV = 0;
	glTextureImage3DMultisampleCoverageNV = 0;
	glTextureImage3DMultisampleNV = 0;

	// ****** GL_NV_texture_rectangle ******
	isGL_NV_texture_rectangle = false;

	// ****** GL_NV_texture_shader ******
	isGL_NV_texture_shader = false;

	// ****** GL_NV_texture_shader2 ******
	isGL_NV_texture_shader2 = false;

	// ****** GL_NV_texture_shader3 ******
	isGL_NV_texture_shader3 = false;

	// ****** GL_NV_transform_feedback ******
	isGL_NV_transform_feedback = false;

	glActiveVaryingNV = 0;
	glBeginTransformFeedbackNV = 0;
	glBindBufferBaseNV = 0;
	glBindBufferOffsetNV = 0;
	glBindBufferRangeNV = 0;
	glEndTransformFeedbackNV = 0;
	glGetActiveVaryingNV = 0;
	glGetTransformFeedbackVaryingNV = 0;
	glGetVaryingLocationNV = 0;
	glTransformFeedbackAttribsNV = 0;
	glTransformFeedbackStreamAttribsNV = 0;
	glTransformFeedbackVaryingsNV = 0;

	// ****** GL_NV_transform_feedback2 ******
	isGL_NV_transform_feedback2 = false;

	glBindTransformFeedbackNV = 0;
	glDeleteTransformFeedbacksNV = 0;
	glDrawTransformFeedbackNV = 0;
	glGenTransformFeedbacksNV = 0;
	glIsTransformFeedbackNV = 0;
	glPauseTransformFeedbackNV = 0;
	glResumeTransformFeedbackNV = 0;

	// ****** GL_NV_vdpau_interop ******
	isGL_NV_vdpau_interop = false;

	glVDPAUFiniNV = 0;
	glVDPAUGetSurfaceivNV = 0;
	glVDPAUInitNV = 0;
	glVDPAUIsSurfaceNV = 0;
	glVDPAUMapSurfacesNV = 0;
	glVDPAURegisterOutputSurfaceNV = 0;
	glVDPAURegisterVideoSurfaceNV = 0;
	glVDPAUSurfaceAccessNV = 0;
	glVDPAUUnmapSurfacesNV = 0;
	glVDPAUUnregisterSurfaceNV = 0;

	// ****** GL_NV_vertex_array_range ******
	isGL_NV_vertex_array_range = false;

	glFlushVertexArrayRangeNV = 0;
	glVertexArrayRangeNV = 0;

	// ****** GL_NV_vertex_array_range2 ******
	isGL_NV_vertex_array_range2 = false;

	// ****** GL_NV_vertex_attrib_integer_64bit ******
	isGL_NV_vertex_attrib_integer_64bit = false;

	glGetVertexAttribLi64vNV = 0;
	glGetVertexAttribLui64vNV = 0;
	glVertexAttribL1i64NV = 0;
	glVertexAttribL1i64vNV = 0;
	glVertexAttribL1ui64NV = 0;
	glVertexAttribL1ui64vNV = 0;
	glVertexAttribL2i64NV = 0;
	glVertexAttribL2i64vNV = 0;
	glVertexAttribL2ui64NV = 0;
	glVertexAttribL2ui64vNV = 0;
	glVertexAttribL3i64NV = 0;
	glVertexAttribL3i64vNV = 0;
	glVertexAttribL3ui64NV = 0;
	glVertexAttribL3ui64vNV = 0;
	glVertexAttribL4i64NV = 0;
	glVertexAttribL4i64vNV = 0;
	glVertexAttribL4ui64NV = 0;
	glVertexAttribL4ui64vNV = 0;
	glVertexAttribLFormatNV = 0;

	// ****** GL_NV_vertex_buffer_unified_memory ******
	isGL_NV_vertex_buffer_unified_memory = false;

	glBufferAddressRangeNV = 0;
	glColorFormatNV = 0;
	glEdgeFlagFormatNV = 0;
	glFogCoordFormatNV = 0;
	glGetIntegerui64i_vNV = 0;
	glIndexFormatNV = 0;
	glNormalFormatNV = 0;
	glSecondaryColorFormatNV = 0;
	glTexCoordFormatNV = 0;
	glVertexAttribFormatNV = 0;
	glVertexAttribIFormatNV = 0;
	glVertexFormatNV = 0;

	// ****** GL_NV_vertex_program ******
	isGL_NV_vertex_program = false;

	glAreProgramsResidentNV = 0;
	glBindProgramNV = 0;
	glDeleteProgramsNV = 0;
	glExecuteProgramNV = 0;
	glGenProgramsNV = 0;
	glGetProgramParameterdvNV = 0;
	glGetProgramParameterfvNV = 0;
	glGetProgramStringNV = 0;
	glGetProgramivNV = 0;
	glGetTrackMatrixivNV = 0;
	glGetVertexAttribPointervNV = 0;
	glGetVertexAttribdvNV = 0;
	glGetVertexAttribfvNV = 0;
	glGetVertexAttribivNV = 0;
	glIsProgramNV = 0;
	glLoadProgramNV = 0;
	glProgramParameter4dNV = 0;
	glProgramParameter4dvNV = 0;
	glProgramParameter4fNV = 0;
	glProgramParameter4fvNV = 0;
	glProgramParameters4dvNV = 0;
	glProgramParameters4fvNV = 0;
	glRequestResidentProgramsNV = 0;
	glTrackMatrixNV = 0;
	glVertexAttrib1dNV = 0;
	glVertexAttrib1dvNV = 0;
	glVertexAttrib1fNV = 0;
	glVertexAttrib1fvNV = 0;
	glVertexAttrib1sNV = 0;
	glVertexAttrib1svNV = 0;
	glVertexAttrib2dNV = 0;
	glVertexAttrib2dvNV = 0;
	glVertexAttrib2fNV = 0;
	glVertexAttrib2fvNV = 0;
	glVertexAttrib2sNV = 0;
	glVertexAttrib2svNV = 0;
	glVertexAttrib3dNV = 0;
	glVertexAttrib3dvNV = 0;
	glVertexAttrib3fNV = 0;
	glVertexAttrib3fvNV = 0;
	glVertexAttrib3sNV = 0;
	glVertexAttrib3svNV = 0;
	glVertexAttrib4dNV = 0;
	glVertexAttrib4dvNV = 0;
	glVertexAttrib4fNV = 0;
	glVertexAttrib4fvNV = 0;
	glVertexAttrib4sNV = 0;
	glVertexAttrib4svNV = 0;
	glVertexAttrib4ubNV = 0;
	glVertexAttrib4ubvNV = 0;
	glVertexAttribPointerNV = 0;
	glVertexAttribs1dvNV = 0;
	glVertexAttribs1fvNV = 0;
	glVertexAttribs1svNV = 0;
	glVertexAttribs2dvNV = 0;
	glVertexAttribs2fvNV = 0;
	glVertexAttribs2svNV = 0;
	glVertexAttribs3dvNV = 0;
	glVertexAttribs3fvNV = 0;
	glVertexAttribs3svNV = 0;
	glVertexAttribs4dvNV = 0;
	glVertexAttribs4fvNV = 0;
	glVertexAttribs4svNV = 0;
	glVertexAttribs4ubvNV = 0;

	// ****** GL_NV_vertex_program1_1 ******
	isGL_NV_vertex_program1_1 = false;

	// ****** GL_NV_vertex_program2 ******
	isGL_NV_vertex_program2 = false;

	// ****** GL_NV_vertex_program2_option ******
	isGL_NV_vertex_program2_option = false;

	// ****** GL_NV_vertex_program3 ******
	isGL_NV_vertex_program3 = false;

	// ****** GL_NV_vertex_program4 ******
	isGL_NV_vertex_program4 = false;

	glGetVertexAttribIivEXT = 0;
	glGetVertexAttribIuivEXT = 0;
	glVertexAttribI1iEXT = 0;
	glVertexAttribI1ivEXT = 0;
	glVertexAttribI1uiEXT = 0;
	glVertexAttribI1uivEXT = 0;
	glVertexAttribI2iEXT = 0;
	glVertexAttribI2ivEXT = 0;
	glVertexAttribI2uiEXT = 0;
	glVertexAttribI2uivEXT = 0;
	glVertexAttribI3iEXT = 0;
	glVertexAttribI3ivEXT = 0;
	glVertexAttribI3uiEXT = 0;
	glVertexAttribI3uivEXT = 0;
	glVertexAttribI4bvEXT = 0;
	glVertexAttribI4iEXT = 0;
	glVertexAttribI4ivEXT = 0;
	glVertexAttribI4svEXT = 0;
	glVertexAttribI4ubvEXT = 0;
	glVertexAttribI4uiEXT = 0;
	glVertexAttribI4uivEXT = 0;
	glVertexAttribI4usvEXT = 0;
	glVertexAttribIPointerEXT = 0;

	// ****** GL_NV_video_capture ******
	isGL_NV_video_capture = false;

	glBeginVideoCaptureNV = 0;
	glBindVideoCaptureStreamBufferNV = 0;
	glBindVideoCaptureStreamTextureNV = 0;
	glEndVideoCaptureNV = 0;
	glGetVideoCaptureStreamdvNV = 0;
	glGetVideoCaptureStreamfvNV = 0;
	glGetVideoCaptureStreamivNV = 0;
	glGetVideoCaptureivNV = 0;
	glVideoCaptureNV = 0;
	glVideoCaptureStreamParameterdvNV = 0;
	glVideoCaptureStreamParameterfvNV = 0;
	glVideoCaptureStreamParameterivNV = 0;

	// ****** GL_OES_byte_coordinates ******
	isGL_OES_byte_coordinates = false;

	glMultiTexCoord1bOES = 0;
	glMultiTexCoord1bvOES = 0;
	glMultiTexCoord2bOES = 0;
	glMultiTexCoord2bvOES = 0;
	glMultiTexCoord3bOES = 0;
	glMultiTexCoord3bvOES = 0;
	glMultiTexCoord4bOES = 0;
	glMultiTexCoord4bvOES = 0;
	glTexCoord1bOES = 0;
	glTexCoord1bvOES = 0;
	glTexCoord2bOES = 0;
	glTexCoord2bvOES = 0;
	glTexCoord3bOES = 0;
	glTexCoord3bvOES = 0;
	glTexCoord4bOES = 0;
	glTexCoord4bvOES = 0;
	glVertex2bOES = 0;
	glVertex2bvOES = 0;
	glVertex3bOES = 0;
	glVertex3bvOES = 0;
	glVertex4bOES = 0;
	glVertex4bvOES = 0;

	// ****** GL_OES_compressed_paletted_texture ******
	isGL_OES_compressed_paletted_texture = false;

	// ****** GL_OES_fixed_point ******
	isGL_OES_fixed_point = false;

	glAccumxOES = 0;
	glAlphaFuncxOES = 0;
	glBitmapxOES = 0;
	glBlendColorxOES = 0;
	glClearAccumxOES = 0;
	glClearColorxOES = 0;
	glClearDepthxOES = 0;
	glClipPlanexOES = 0;
	glColor3xOES = 0;
	glColor3xvOES = 0;
	glColor4xOES = 0;
	glColor4xvOES = 0;
	glConvolutionParameterxOES = 0;
	glConvolutionParameterxvOES = 0;
	glDepthRangexOES = 0;
	glEvalCoord1xOES = 0;
	glEvalCoord1xvOES = 0;
	glEvalCoord2xOES = 0;
	glEvalCoord2xvOES = 0;
	glFeedbackBufferxOES = 0;
	glFogxOES = 0;
	glFogxvOES = 0;
	glFrustumxOES = 0;
	glGetClipPlanexOES = 0;
	glGetConvolutionParameterxvOES = 0;
	glGetFixedvOES = 0;
	glGetHistogramParameterxvOES = 0;
	glGetLightxOES = 0;
	glGetMapxvOES = 0;
	glGetMaterialxOES = 0;
	glGetPixelMapxv = 0;
	glGetTexEnvxvOES = 0;
	glGetTexGenxvOES = 0;
	glGetTexLevelParameterxvOES = 0;
	glGetTexParameterxvOES = 0;
	glIndexxOES = 0;
	glIndexxvOES = 0;
	glLightModelxOES = 0;
	glLightModelxvOES = 0;
	glLightxOES = 0;
	glLightxvOES = 0;
	glLineWidthxOES = 0;
	glLoadMatrixxOES = 0;
	glLoadTransposeMatrixxOES = 0;
	glMap1xOES = 0;
	glMap2xOES = 0;
	glMapGrid1xOES = 0;
	glMapGrid2xOES = 0;
	glMaterialxOES = 0;
	glMaterialxvOES = 0;
	glMultMatrixxOES = 0;
	glMultTransposeMatrixxOES = 0;
	glMultiTexCoord1xOES = 0;
	glMultiTexCoord1xvOES = 0;
	glMultiTexCoord2xOES = 0;
	glMultiTexCoord2xvOES = 0;
	glMultiTexCoord3xOES = 0;
	glMultiTexCoord3xvOES = 0;
	glMultiTexCoord4xOES = 0;
	glMultiTexCoord4xvOES = 0;
	glNormal3xOES = 0;
	glNormal3xvOES = 0;
	glOrthoxOES = 0;
	glPassThroughxOES = 0;
	glPixelMapx = 0;
	glPixelStorex = 0;
	glPixelTransferxOES = 0;
	glPixelZoomxOES = 0;
	glPointParameterxvOES = 0;
	glPointSizexOES = 0;
	glPolygonOffsetxOES = 0;
	glPrioritizeTexturesxOES = 0;
	glRasterPos2xOES = 0;
	glRasterPos2xvOES = 0;
	glRasterPos3xOES = 0;
	glRasterPos3xvOES = 0;
	glRasterPos4xOES = 0;
	glRasterPos4xvOES = 0;
	glRectxOES = 0;
	glRectxvOES = 0;
	glRotatexOES = 0;
	glSampleCoverageOES = 0;
	glScalexOES = 0;
	glTexCoord1xOES = 0;
	glTexCoord1xvOES = 0;
	glTexCoord2xOES = 0;
	glTexCoord2xvOES = 0;
	glTexCoord3xOES = 0;
	glTexCoord3xvOES = 0;
	glTexCoord4xOES = 0;
	glTexCoord4xvOES = 0;
	glTexEnvxOES = 0;
	glTexEnvxvOES = 0;
	glTexGenxOES = 0;
	glTexGenxvOES = 0;
	glTexParameterxOES = 0;
	glTexParameterxvOES = 0;
	glTranslatexOES = 0;
	glVertex2xOES = 0;
	glVertex2xvOES = 0;
	glVertex3xOES = 0;
	glVertex3xvOES = 0;
	glVertex4xOES = 0;
	glVertex4xvOES = 0;

	// ****** GL_OES_query_matrix ******
	isGL_OES_query_matrix = false;

	glQueryMatrixxOES = 0;

	// ****** GL_OES_read_format ******
	isGL_OES_read_format = false;

	// ****** GL_OES_single_precision ******
	isGL_OES_single_precision = false;

	glClearDepthfOES = 0;
	glClipPlanefOES = 0;
	glDepthRangefOES = 0;
	glFrustumfOES = 0;
	glGetClipPlanefOES = 0;
	glOrthofOES = 0;

	// ****** GL_OML_interlace ******
	isGL_OML_interlace = false;

	// ****** GL_OML_resample ******
	isGL_OML_resample = false;

	// ****** GL_OML_subsample ******
	isGL_OML_subsample = false;

	// ****** GL_PGI_misc_hints ******
	isGL_PGI_misc_hints = false;

	glHintPGI = 0;

	// ****** GL_PGI_vertex_hints ******
	isGL_PGI_vertex_hints = false;

	// ****** GL_REND_screen_coordinates ******
	isGL_REND_screen_coordinates = false;

	// ****** GL_S3_s3tc ******
	isGL_S3_s3tc = false;

	// ****** GL_SGIS_detail_texture ******
	isGL_SGIS_detail_texture = false;

	glDetailTexFuncSGIS = 0;
	glGetDetailTexFuncSGIS = 0;

	// ****** GL_SGIS_fog_function ******
	isGL_SGIS_fog_function = false;

	glFogFuncSGIS = 0;
	glGetFogFuncSGIS = 0;

	// ****** GL_SGIS_generate_mipmap ******
	isGL_SGIS_generate_mipmap = false;

	// ****** GL_SGIS_multisample ******
	isGL_SGIS_multisample = false;

	glSampleMaskSGIS = 0;
	glSamplePatternSGIS = 0;

	// ****** GL_SGIS_pixel_texture ******
	isGL_SGIS_pixel_texture = false;

	glGetPixelTexGenParameterfvSGIS = 0;
	glGetPixelTexGenParameterivSGIS = 0;
	glPixelTexGenParameterfSGIS = 0;
	glPixelTexGenParameterfvSGIS = 0;
	glPixelTexGenParameteriSGIS = 0;
	glPixelTexGenParameterivSGIS = 0;

	// ****** GL_SGIS_point_line_texgen ******
	isGL_SGIS_point_line_texgen = false;

	// ****** GL_SGIS_point_parameters ******
	isGL_SGIS_point_parameters = false;

	glPointParameterfSGIS = 0;
	glPointParameterfvSGIS = 0;

	// ****** GL_SGIS_sharpen_texture ******
	isGL_SGIS_sharpen_texture = false;

	glGetSharpenTexFuncSGIS = 0;
	glSharpenTexFuncSGIS = 0;

	// ****** GL_SGIS_texture4D ******
	isGL_SGIS_texture4D = false;

	glTexImage4DSGIS = 0;
	glTexSubImage4DSGIS = 0;

	// ****** GL_SGIS_texture_border_clamp ******
	isGL_SGIS_texture_border_clamp = false;

	// ****** GL_SGIS_texture_color_mask ******
	isGL_SGIS_texture_color_mask = false;

	glTextureColorMaskSGIS = 0;

	// ****** GL_SGIS_texture_edge_clamp ******
	isGL_SGIS_texture_edge_clamp = false;

	// ****** GL_SGIS_texture_filter4 ******
	isGL_SGIS_texture_filter4 = false;

	glGetTexFilterFuncSGIS = 0;
	glTexFilterFuncSGIS = 0;

	// ****** GL_SGIS_texture_lod ******
	isGL_SGIS_texture_lod = false;

	// ****** GL_SGIS_texture_select ******
	isGL_SGIS_texture_select = false;

	// ****** GL_SGIX_async ******
	isGL_SGIX_async = false;

	glAsyncMarkerSGIX = 0;
	glDeleteAsyncMarkersSGIX = 0;
	glFinishAsyncSGIX = 0;
	glGenAsyncMarkersSGIX = 0;
	glIsAsyncMarkerSGIX = 0;
	glPollAsyncSGIX = 0;

	// ****** GL_SGIX_async_histogram ******
	isGL_SGIX_async_histogram = false;

	// ****** GL_SGIX_async_pixel ******
	isGL_SGIX_async_pixel = false;

	// ****** GL_SGIX_blend_alpha_minmax ******
	isGL_SGIX_blend_alpha_minmax = false;

	// ****** GL_SGIX_calligraphic_fragment ******
	isGL_SGIX_calligraphic_fragment = false;

	// ****** GL_SGIX_clipmap ******
	isGL_SGIX_clipmap = false;

	// ****** GL_SGIX_convolution_accuracy ******
	isGL_SGIX_convolution_accuracy = false;

	// ****** GL_SGIX_depth_pass_instrument ******
	isGL_SGIX_depth_pass_instrument = false;

	// ****** GL_SGIX_depth_texture ******
	isGL_SGIX_depth_texture = false;

	// ****** GL_SGIX_flush_raster ******
	isGL_SGIX_flush_raster = false;

	glFlushRasterSGIX = 0;

	// ****** GL_SGIX_fog_offset ******
	isGL_SGIX_fog_offset = false;

	// ****** GL_SGIX_fog_scale ******
	isGL_SGIX_fog_scale = false;

	// ****** GL_SGIX_fragment_lighting ******
	isGL_SGIX_fragment_lighting = false;

	glFragmentColorMaterialSGIX = 0;
	glFragmentLightModelfSGIX = 0;
	glFragmentLightModelfvSGIX = 0;
	glFragmentLightModeliSGIX = 0;
	glFragmentLightModelivSGIX = 0;
	glFragmentLightfSGIX = 0;
	glFragmentLightfvSGIX = 0;
	glFragmentLightiSGIX = 0;
	glFragmentLightivSGIX = 0;
	glFragmentMaterialfSGIX = 0;
	glFragmentMaterialfvSGIX = 0;
	glFragmentMaterialiSGIX = 0;
	glFragmentMaterialivSGIX = 0;
	glGetFragmentLightfvSGIX = 0;
	glGetFragmentLightivSGIX = 0;
	glGetFragmentMaterialfvSGIX = 0;
	glGetFragmentMaterialivSGIX = 0;
	glLightEnviSGIX = 0;

	// ****** GL_SGIX_framezoom ******
	isGL_SGIX_framezoom = false;

	glFrameZoomSGIX = 0;

	// ****** GL_SGIX_igloo_interface ******
	isGL_SGIX_igloo_interface = false;

	glIglooInterfaceSGIX = 0;

	// ****** GL_SGIX_impact_pixel_texture ******
	isGL_SGIX_impact_pixel_texture = false;

	// ****** GL_SGIX_instruments ******
	isGL_SGIX_instruments = false;

	glGetInstrumentsSGIX = 0;
	glInstrumentsBufferSGIX = 0;
	glPollInstrumentsSGIX = 0;
	glReadInstrumentsSGIX = 0;
	glStartInstrumentsSGIX = 0;
	glStopInstrumentsSGIX = 0;

	// ****** GL_SGIX_interlace ******
	isGL_SGIX_interlace = false;

	// ****** GL_SGIX_ir_instrument1 ******
	isGL_SGIX_ir_instrument1 = false;

	// ****** GL_SGIX_list_priority ******
	isGL_SGIX_list_priority = false;

	glGetListParameterfvSGIX = 0;
	glGetListParameterivSGIX = 0;
	glListParameterfSGIX = 0;
	glListParameterfvSGIX = 0;
	glListParameteriSGIX = 0;
	glListParameterivSGIX = 0;

	// ****** GL_SGIX_pixel_texture ******
	isGL_SGIX_pixel_texture = false;

	glPixelTexGenSGIX = 0;

	// ****** GL_SGIX_pixel_tiles ******
	isGL_SGIX_pixel_tiles = false;

	// ****** GL_SGIX_polynomial_ffd ******
	isGL_SGIX_polynomial_ffd = false;

	glDeformSGIX = 0;
	glDeformationMap3dSGIX = 0;
	glDeformationMap3fSGIX = 0;
	glLoadIdentityDeformationMapSGIX = 0;

	// ****** GL_SGIX_reference_plane ******
	isGL_SGIX_reference_plane = false;

	glReferencePlaneSGIX = 0;

	// ****** GL_SGIX_resample ******
	isGL_SGIX_resample = false;

	// ****** GL_SGIX_scalebias_hint ******
	isGL_SGIX_scalebias_hint = false;

	// ****** GL_SGIX_shadow ******
	isGL_SGIX_shadow = false;

	// ****** GL_SGIX_shadow_ambient ******
	isGL_SGIX_shadow_ambient = false;

	// ****** GL_SGIX_sprite ******
	isGL_SGIX_sprite = false;

	glSpriteParameterfSGIX = 0;
	glSpriteParameterfvSGIX = 0;
	glSpriteParameteriSGIX = 0;
	glSpriteParameterivSGIX = 0;

	// ****** GL_SGIX_subsample ******
	isGL_SGIX_subsample = false;

	// ****** GL_SGIX_tag_sample_buffer ******
	isGL_SGIX_tag_sample_buffer = false;

	glTagSampleBufferSGIX = 0;

	// ****** GL_SGIX_texture_add_env ******
	isGL_SGIX_texture_add_env = false;

	// ****** GL_SGIX_texture_coordinate_clamp ******
	isGL_SGIX_texture_coordinate_clamp = false;

	// ****** GL_SGIX_texture_lod_bias ******
	isGL_SGIX_texture_lod_bias = false;

	// ****** GL_SGIX_texture_multi_buffer ******
	isGL_SGIX_texture_multi_buffer = false;

	// ****** GL_SGIX_texture_scale_bias ******
	isGL_SGIX_texture_scale_bias = false;

	// ****** GL_SGIX_texture_select ******
	isGL_SGIX_texture_select = false;

	// ****** GL_SGIX_vertex_preclip ******
	isGL_SGIX_vertex_preclip = false;

	// ****** GL_SGIX_ycrcb ******
	isGL_SGIX_ycrcb = false;

	// ****** GL_SGIX_ycrcb_subsample ******
	isGL_SGIX_ycrcb_subsample = false;

	// ****** GL_SGIX_ycrcba ******
	isGL_SGIX_ycrcba = false;

	// ****** GL_SGI_color_matrix ******
	isGL_SGI_color_matrix = false;

	// ****** GL_SGI_color_table ******
	isGL_SGI_color_table = false;

	glColorTableParameterfvSGI = 0;
	glColorTableParameterivSGI = 0;
	glColorTableSGI = 0;
	glCopyColorTableSGI = 0;
	glGetColorTableParameterfvSGI = 0;
	glGetColorTableParameterivSGI = 0;
	glGetColorTableSGI = 0;

	// ****** GL_SGI_depth_pass_instrument ******
	isGL_SGI_depth_pass_instrument = false;

	// ****** GL_SGI_texture_color_table ******
	isGL_SGI_texture_color_table = false;

	// ****** GL_SUNX_constant_data ******
	isGL_SUNX_constant_data = false;

	glFinishTextureSUNX = 0;

	// ****** GL_SUN_convolution_border_modes ******
	isGL_SUN_convolution_border_modes = false;

	// ****** GL_SUN_global_alpha ******
	isGL_SUN_global_alpha = false;

	glGlobalAlphaFactorbSUN = 0;
	glGlobalAlphaFactordSUN = 0;
	glGlobalAlphaFactorfSUN = 0;
	glGlobalAlphaFactoriSUN = 0;
	glGlobalAlphaFactorsSUN = 0;
	glGlobalAlphaFactorubSUN = 0;
	glGlobalAlphaFactoruiSUN = 0;
	glGlobalAlphaFactorusSUN = 0;

	// ****** GL_SUN_mesh_array ******
	isGL_SUN_mesh_array = false;

	glDrawMeshArraysSUN = 0;

	// ****** GL_SUN_slice_accum ******
	isGL_SUN_slice_accum = false;

	// ****** GL_SUN_triangle_list ******
	isGL_SUN_triangle_list = false;

	glReplacementCodePointerSUN = 0;
	glReplacementCodeubSUN = 0;
	glReplacementCodeubvSUN = 0;
	glReplacementCodeuiSUN = 0;
	glReplacementCodeuivSUN = 0;
	glReplacementCodeusSUN = 0;
	glReplacementCodeusvSUN = 0;

	// ****** GL_SUN_vertex ******
	isGL_SUN_vertex = false;

	glColor3fVertex3fSUN = 0;
	glColor3fVertex3fvSUN = 0;
	glColor4fNormal3fVertex3fSUN = 0;
	glColor4fNormal3fVertex3fvSUN = 0;
	glColor4ubVertex2fSUN = 0;
	glColor4ubVertex2fvSUN = 0;
	glColor4ubVertex3fSUN = 0;
	glColor4ubVertex3fvSUN = 0;
	glNormal3fVertex3fSUN = 0;
	glNormal3fVertex3fvSUN = 0;
	glReplacementCodeuiColor3fVertex3fSUN = 0;
	glReplacementCodeuiColor3fVertex3fvSUN = 0;
	glReplacementCodeuiColor4fNormal3fVertex3fSUN = 0;
	glReplacementCodeuiColor4fNormal3fVertex3fvSUN = 0;
	glReplacementCodeuiColor4ubVertex3fSUN = 0;
	glReplacementCodeuiColor4ubVertex3fvSUN = 0;
	glReplacementCodeuiNormal3fVertex3fSUN = 0;
	glReplacementCodeuiNormal3fVertex3fvSUN = 0;
	glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = 0;
	glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = 0;
	glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = 0;
	glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = 0;
	glReplacementCodeuiTexCoord2fVertex3fSUN = 0;
	glReplacementCodeuiTexCoord2fVertex3fvSUN = 0;
	glReplacementCodeuiVertex3fSUN = 0;
	glReplacementCodeuiVertex3fvSUN = 0;
	glTexCoord2fColor3fVertex3fSUN = 0;
	glTexCoord2fColor3fVertex3fvSUN = 0;
	glTexCoord2fColor4fNormal3fVertex3fSUN = 0;
	glTexCoord2fColor4fNormal3fVertex3fvSUN = 0;
	glTexCoord2fColor4ubVertex3fSUN = 0;
	glTexCoord2fColor4ubVertex3fvSUN = 0;
	glTexCoord2fNormal3fVertex3fSUN = 0;
	glTexCoord2fNormal3fVertex3fvSUN = 0;
	glTexCoord2fVertex3fSUN = 0;
	glTexCoord2fVertex3fvSUN = 0;
	glTexCoord4fColor4fNormal3fVertex4fSUN = 0;
	glTexCoord4fColor4fNormal3fVertex4fvSUN = 0;
	glTexCoord4fVertex4fSUN = 0;
	glTexCoord4fVertex4fvSUN = 0;

	// ****** GL_VERSION_1_2 ******
	isGL_VERSION_1_2 = false;

	glBlendColor = 0;
	glBlendEquation = 0;
	glColorSubTable = 0;
	glColorTable = 0;
	glColorTableParameterfv = 0;
	glColorTableParameteriv = 0;
	glConvolutionFilter1D = 0;
	glConvolutionFilter2D = 0;
	glConvolutionParameterf = 0;
	glConvolutionParameterfv = 0;
	glConvolutionParameteri = 0;
	glConvolutionParameteriv = 0;
	glCopyColorSubTable = 0;
	glCopyColorTable = 0;
	glCopyConvolutionFilter1D = 0;
	glCopyConvolutionFilter2D = 0;
	glCopyTexSubImage3D = 0;
	glDrawRangeElements = 0;
	glGetColorTable = 0;
	glGetColorTableParameterfv = 0;
	glGetColorTableParameteriv = 0;
	glGetConvolutionFilter = 0;
	glGetConvolutionParameterfv = 0;
	glGetConvolutionParameteriv = 0;
	glGetHistogram = 0;
	glGetHistogramParameterfv = 0;
	glGetHistogramParameteriv = 0;
	glGetMinmax = 0;
	glGetMinmaxParameterfv = 0;
	glGetMinmaxParameteriv = 0;
	glGetSeparableFilter = 0;
	glHistogram = 0;
	glMinmax = 0;
	glResetHistogram = 0;
	glResetMinmax = 0;
	glSeparableFilter2D = 0;
	glTexImage3D = 0;
	glTexSubImage3D = 0;

	// ****** GL_VERSION_1_3 ******
	isGL_VERSION_1_3 = false;

	glActiveTexture = 0;
	glClientActiveTexture = 0;
	glCompressedTexImage1D = 0;
	glCompressedTexImage2D = 0;
	glCompressedTexImage3D = 0;
	glCompressedTexSubImage1D = 0;
	glCompressedTexSubImage2D = 0;
	glCompressedTexSubImage3D = 0;
	glGetCompressedTexImage = 0;
	glLoadTransposeMatrixd = 0;
	glLoadTransposeMatrixf = 0;
	glMultTransposeMatrixd = 0;
	glMultTransposeMatrixf = 0;
	glMultiTexCoord1d = 0;
	glMultiTexCoord1dv = 0;
	glMultiTexCoord1f = 0;
	glMultiTexCoord1fv = 0;
	glMultiTexCoord1i = 0;
	glMultiTexCoord1iv = 0;
	glMultiTexCoord1s = 0;
	glMultiTexCoord1sv = 0;
	glMultiTexCoord2d = 0;
	glMultiTexCoord2dv = 0;
	glMultiTexCoord2f = 0;
	glMultiTexCoord2fv = 0;
	glMultiTexCoord2i = 0;
	glMultiTexCoord2iv = 0;
	glMultiTexCoord2s = 0;
	glMultiTexCoord2sv = 0;
	glMultiTexCoord3d = 0;
	glMultiTexCoord3dv = 0;
	glMultiTexCoord3f = 0;
	glMultiTexCoord3fv = 0;
	glMultiTexCoord3i = 0;
	glMultiTexCoord3iv = 0;
	glMultiTexCoord3s = 0;
	glMultiTexCoord3sv = 0;
	glMultiTexCoord4d = 0;
	glMultiTexCoord4dv = 0;
	glMultiTexCoord4f = 0;
	glMultiTexCoord4fv = 0;
	glMultiTexCoord4i = 0;
	glMultiTexCoord4iv = 0;
	glMultiTexCoord4s = 0;
	glMultiTexCoord4sv = 0;
	glSampleCoverage = 0;

	// ****** GL_VERSION_1_4 ******
	isGL_VERSION_1_4 = false;

	glBlendFuncSeparate = 0;
	glFogCoordPointer = 0;
	glFogCoordd = 0;
	glFogCoorddv = 0;
	glFogCoordf = 0;
	glFogCoordfv = 0;
	glMultiDrawArrays = 0;
	glMultiDrawElements = 0;
	glPointParameterf = 0;
	glPointParameterfv = 0;
	glPointParameteri = 0;
	glPointParameteriv = 0;
	glSecondaryColor3b = 0;
	glSecondaryColor3bv = 0;
	glSecondaryColor3d = 0;
	glSecondaryColor3dv = 0;
	glSecondaryColor3f = 0;
	glSecondaryColor3fv = 0;
	glSecondaryColor3i = 0;
	glSecondaryColor3iv = 0;
	glSecondaryColor3s = 0;
	glSecondaryColor3sv = 0;
	glSecondaryColor3ub = 0;
	glSecondaryColor3ubv = 0;
	glSecondaryColor3ui = 0;
	glSecondaryColor3uiv = 0;
	glSecondaryColor3us = 0;
	glSecondaryColor3usv = 0;
	glSecondaryColorPointer = 0;
	glWindowPos2d = 0;
	glWindowPos2dv = 0;
	glWindowPos2f = 0;
	glWindowPos2fv = 0;
	glWindowPos2i = 0;
	glWindowPos2iv = 0;
	glWindowPos2s = 0;
	glWindowPos2sv = 0;
	glWindowPos3d = 0;
	glWindowPos3dv = 0;
	glWindowPos3f = 0;
	glWindowPos3fv = 0;
	glWindowPos3i = 0;
	glWindowPos3iv = 0;
	glWindowPos3s = 0;
	glWindowPos3sv = 0;

	// ****** GL_VERSION_1_5 ******
	isGL_VERSION_1_5 = false;

	glBeginQuery = 0;
	glBindBuffer = 0;
	glBufferData = 0;
	glBufferSubData = 0;
	glDeleteBuffers = 0;
	glDeleteQueries = 0;
	glEndQuery = 0;
	glGenBuffers = 0;
	glGenQueries = 0;
	glGetBufferParameteriv = 0;
	glGetBufferPointerv = 0;
	glGetBufferSubData = 0;
	glGetQueryObjectiv = 0;
	glGetQueryObjectuiv = 0;
	glGetQueryiv = 0;
	glIsBuffer = 0;
	glIsQuery = 0;
	glMapBuffer = 0;
	glUnmapBuffer = 0;

	// ****** GL_VERSION_2_0 ******
	isGL_VERSION_2_0 = false;

	glAttachShader = 0;
	glBindAttribLocation = 0;
	glBlendEquationSeparate = 0;
	glCompileShader = 0;
	glCreateProgram = 0;
	glCreateShader = 0;
	glDeleteProgram = 0;
	glDeleteShader = 0;
	glDetachShader = 0;
	glDisableVertexAttribArray = 0;
	glDrawBuffers = 0;
	glEnableVertexAttribArray = 0;
	glGetActiveAttrib = 0;
	glGetActiveUniform = 0;
	glGetAttachedShaders = 0;
	glGetAttribLocation = 0;
	glGetProgramInfoLog = 0;
	glGetProgramiv = 0;
	glGetShaderInfoLog = 0;
	glGetShaderSource = 0;
	glGetShaderiv = 0;
	glGetUniformLocation = 0;
	glGetUniformfv = 0;
	glGetUniformiv = 0;
	glGetVertexAttribPointerv = 0;
	glGetVertexAttribdv = 0;
	glGetVertexAttribfv = 0;
	glGetVertexAttribiv = 0;
	glIsProgram = 0;
	glIsShader = 0;
	glLinkProgram = 0;
	glShaderSource = 0;
	glStencilFuncSeparate = 0;
	glStencilMaskSeparate = 0;
	glStencilOpSeparate = 0;
	glUniform1f = 0;
	glUniform1fv = 0;
	glUniform1i = 0;
	glUniform1iv = 0;
	glUniform2f = 0;
	glUniform2fv = 0;
	glUniform2i = 0;
	glUniform2iv = 0;
	glUniform3f = 0;
	glUniform3fv = 0;
	glUniform3i = 0;
	glUniform3iv = 0;
	glUniform4f = 0;
	glUniform4fv = 0;
	glUniform4i = 0;
	glUniform4iv = 0;
	glUniformMatrix2fv = 0;
	glUniformMatrix3fv = 0;
	glUniformMatrix4fv = 0;
	glUseProgram = 0;
	glValidateProgram = 0;
	glVertexAttrib1d = 0;
	glVertexAttrib1dv = 0;
	glVertexAttrib1f = 0;
	glVertexAttrib1fv = 0;
	glVertexAttrib1s = 0;
	glVertexAttrib1sv = 0;
	glVertexAttrib2d = 0;
	glVertexAttrib2dv = 0;
	glVertexAttrib2f = 0;
	glVertexAttrib2fv = 0;
	glVertexAttrib2s = 0;
	glVertexAttrib2sv = 0;
	glVertexAttrib3d = 0;
	glVertexAttrib3dv = 0;
	glVertexAttrib3f = 0;
	glVertexAttrib3fv = 0;
	glVertexAttrib3s = 0;
	glVertexAttrib3sv = 0;
	glVertexAttrib4Nbv = 0;
	glVertexAttrib4Niv = 0;
	glVertexAttrib4Nsv = 0;
	glVertexAttrib4Nub = 0;
	glVertexAttrib4Nubv = 0;
	glVertexAttrib4Nuiv = 0;
	glVertexAttrib4Nusv = 0;
	glVertexAttrib4bv = 0;
	glVertexAttrib4d = 0;
	glVertexAttrib4dv = 0;
	glVertexAttrib4f = 0;
	glVertexAttrib4fv = 0;
	glVertexAttrib4iv = 0;
	glVertexAttrib4s = 0;
	glVertexAttrib4sv = 0;
	glVertexAttrib4ubv = 0;
	glVertexAttrib4uiv = 0;
	glVertexAttrib4usv = 0;
	glVertexAttribPointer = 0;

	// ****** GL_VERSION_2_1 ******
	isGL_VERSION_2_1 = false;

	glUniformMatrix2x3fv = 0;
	glUniformMatrix2x4fv = 0;
	glUniformMatrix3x2fv = 0;
	glUniformMatrix3x4fv = 0;
	glUniformMatrix4x2fv = 0;
	glUniformMatrix4x3fv = 0;

	// ****** GL_VERSION_3_0 ******
	isGL_VERSION_3_0 = false;

	glBeginConditionalRender = 0;
	glBeginTransformFeedback = 0;
	glBindBufferBase = 0;
	glBindBufferRange = 0;
	glBindFragDataLocation = 0;
	glClampColor = 0;
	glClearBufferfi = 0;
	glClearBufferfv = 0;
	glClearBufferiv = 0;
	glClearBufferuiv = 0;
	glColorMaski = 0;
	glDisablei = 0;
	glEnablei = 0;
	glEndConditionalRender = 0;
	glEndTransformFeedback = 0;
	glGetBooleani_v = 0;
	glGetFragDataLocation = 0;
	glGetIntegeri_v = 0;
	glGetStringi = 0;
	glGetTexParameterIiv = 0;
	glGetTexParameterIuiv = 0;
	glGetTransformFeedbackVarying = 0;
	glGetUniformuiv = 0;
	glGetVertexAttribIiv = 0;
	glGetVertexAttribIuiv = 0;
	glIsEnabledi = 0;
	glTexParameterIiv = 0;
	glTexParameterIuiv = 0;
	glTransformFeedbackVaryings = 0;
	glUniform1ui = 0;
	glUniform1uiv = 0;
	glUniform2ui = 0;
	glUniform2uiv = 0;
	glUniform3ui = 0;
	glUniform3uiv = 0;
	glUniform4ui = 0;
	glUniform4uiv = 0;
	glVertexAttribI1i = 0;
	glVertexAttribI1iv = 0;
	glVertexAttribI1ui = 0;
	glVertexAttribI1uiv = 0;
	glVertexAttribI2i = 0;
	glVertexAttribI2iv = 0;
	glVertexAttribI2ui = 0;
	glVertexAttribI2uiv = 0;
	glVertexAttribI3i = 0;
	glVertexAttribI3iv = 0;
	glVertexAttribI3ui = 0;
	glVertexAttribI3uiv = 0;
	glVertexAttribI4bv = 0;
	glVertexAttribI4i = 0;
	glVertexAttribI4iv = 0;
	glVertexAttribI4sv = 0;
	glVertexAttribI4ubv = 0;
	glVertexAttribI4ui = 0;
	glVertexAttribI4uiv = 0;
	glVertexAttribI4usv = 0;
	glVertexAttribIPointer = 0;

	// ****** GL_VERSION_3_1 ******
	isGL_VERSION_3_1 = false;

	glDrawArraysInstanced = 0;
	glDrawElementsInstanced = 0;
	glPrimitiveRestartIndex = 0;
	glTexBuffer = 0;

	// ****** GL_VERSION_3_2 ******
	isGL_VERSION_3_2 = false;

	glFramebufferTexture = 0;
	glGetBufferParameteri64v = 0;
	glGetInteger64i_v = 0;

	// ****** GL_VERSION_3_3 ******
	isGL_VERSION_3_3 = false;

	glVertexAttribDivisor = 0;

	// ****** GL_VERSION_4_0 ******
	isGL_VERSION_4_0 = false;

	glBlendEquationSeparatei = 0;
	glBlendEquationi = 0;
	glBlendFuncSeparatei = 0;
	glBlendFunci = 0;
	glMinSampleShading = 0;

	// ****** GL_VERSION_4_1 ******
	isGL_VERSION_4_1 = false;

	// ****** GL_VERSION_4_2 ******
	isGL_VERSION_4_2 = false;

	// ****** GL_VERSION_4_3 ******
	isGL_VERSION_4_3 = false;

	// ****** GL_WIN_phong_shading ******
	isGL_WIN_phong_shading = false;

	// ****** GL_WIN_specular_fog ******
	isGL_WIN_specular_fog = false;
#ifdef WIN32
	// ****** WGL_3DFX_multisample ******
	isWGL_3DFX_multisample = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_3DL_stereo_control ******
	isWGL_3DL_stereo_control = false;

	wglSetStereoEmitterState3DL = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_AMD_gpu_association ******
	isWGL_AMD_gpu_association = false;

	wglBlitContextFramebufferAMD = 0;
	wglCreateAssociatedContextAMD = 0;
	wglCreateAssociatedContextAttribsAMD = 0;
	wglDeleteAssociatedContextAMD = 0;
	wglGetContextGPUIDAMD = 0;
	wglGetCurrentAssociatedContextAMD = 0;
	wglGetGPUIDsAMD = 0;
	wglGetGPUInfoAMD = 0;
	wglMakeAssociatedContextCurrentAMD = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_buffer_region ******
	isWGL_ARB_buffer_region = false;

	wglCreateBufferRegionARB = 0;
	wglDeleteBufferRegionARB = 0;
	wglRestoreBufferRegionARB = 0;
	wglSaveBufferRegionARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_create_context ******
	isWGL_ARB_create_context = false;

	wglCreateContextAttribsARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_create_context_profile ******
	isWGL_ARB_create_context_profile = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_create_context_robustness ******
	isWGL_ARB_create_context_robustness = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_extensions_string ******
	isWGL_ARB_extensions_string = false;

	wglGetExtensionsStringARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_framebuffer_sRGB ******
	isWGL_ARB_framebuffer_sRGB = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_make_current_read ******
	isWGL_ARB_make_current_read = false;

	wglGetCurrentReadDCARB = 0;
	wglMakeContextCurrentARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_multisample ******
	isWGL_ARB_multisample = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_pbuffer ******
	isWGL_ARB_pbuffer = false;

	wglCreatePbufferARB = 0;
	wglDestroyPbufferARB = 0;
	wglGetPbufferDCARB = 0;
	wglQueryPbufferARB = 0;
	wglReleasePbufferDCARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_pixel_format ******
	isWGL_ARB_pixel_format = false;

	wglChoosePixelFormatARB = 0;
	wglGetPixelFormatAttribfvARB = 0;
	wglGetPixelFormatAttribivARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_pixel_format_float ******
	isWGL_ARB_pixel_format_float = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ARB_render_texture ******
	isWGL_ARB_render_texture = false;

	wglBindTexImageARB = 0;
	wglReleaseTexImageARB = 0;
	wglSetPbufferAttribARB = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_ATI_pixel_format_float ******
	isWGL_ATI_pixel_format_float = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_create_context_es2_profile ******
	isWGL_EXT_create_context_es2_profile = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_depth_float ******
	isWGL_EXT_depth_float = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_display_color_table ******
	isWGL_EXT_display_color_table = false;

	wglBindDisplayColorTableEXT = 0;
	wglCreateDisplayColorTableEXT = 0;
	wglDestroyDisplayColorTableEXT = 0;
	wglLoadDisplayColorTableEXT = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_extensions_string ******
	isWGL_EXT_extensions_string = false;

	wglGetExtensionsStringEXT = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_framebuffer_sRGB ******
	isWGL_EXT_framebuffer_sRGB = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_make_current_read ******
	isWGL_EXT_make_current_read = false;

	wglGetCurrentReadDCEXT = 0;
	wglMakeContextCurrentEXT = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_multisample ******
	isWGL_EXT_multisample = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_pbuffer ******
	isWGL_EXT_pbuffer = false;

	wglCreatePbufferEXT = 0;
	wglDestroyPbufferEXT = 0;
	wglGetPbufferDCEXT = 0;
	wglQueryPbufferEXT = 0;
	wglReleasePbufferDCEXT = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_pixel_format ******
	isWGL_EXT_pixel_format = false;

	wglChoosePixelFormatEXT = 0;
	wglGetPixelFormatAttribfvEXT = 0;
	wglGetPixelFormatAttribivEXT = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_pixel_format_packed_float ******
	isWGL_EXT_pixel_format_packed_float = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_swap_control ******
	isWGL_EXT_swap_control = false;

	wglGetSwapIntervalEXT = 0;
	wglSwapIntervalEXT = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_EXT_swap_control_tear ******
	isWGL_EXT_swap_control_tear = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_I3D_digital_video_control ******
	isWGL_I3D_digital_video_control = false;

	wglGetDigitalVideoParametersI3D = 0;
	wglSetDigitalVideoParametersI3D = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_I3D_gamma ******
	isWGL_I3D_gamma = false;

	wglGetGammaTableI3D = 0;
	wglGetGammaTableParametersI3D = 0;
	wglSetGammaTableI3D = 0;
	wglSetGammaTableParametersI3D = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_I3D_genlock ******
	isWGL_I3D_genlock = false;

	wglDisableGenlockI3D = 0;
	wglEnableGenlockI3D = 0;
	wglGenlockSampleRateI3D = 0;
	wglGenlockSourceDelayI3D = 0;
	wglGenlockSourceEdgeI3D = 0;
	wglGenlockSourceI3D = 0;
	wglGetGenlockSampleRateI3D = 0;
	wglGetGenlockSourceDelayI3D = 0;
	wglGetGenlockSourceEdgeI3D = 0;
	wglGetGenlockSourceI3D = 0;
	wglIsEnabledGenlockI3D = 0;
	wglQueryGenlockMaxSourceDelayI3D = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_I3D_image_buffer ******
	isWGL_I3D_image_buffer = false;

	wglAssociateImageBufferEventsI3D = 0;
	wglCreateImageBufferI3D = 0;
	wglDestroyImageBufferI3D = 0;
	wglReleaseImageBufferEventsI3D = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_I3D_swap_frame_lock ******
	isWGL_I3D_swap_frame_lock = false;

	wglDisableFrameLockI3D = 0;
	wglEnableFrameLockI3D = 0;
	wglIsEnabledFrameLockI3D = 0;
	wglQueryFrameLockMasterI3D = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_I3D_swap_frame_usage ******
	isWGL_I3D_swap_frame_usage = false;

	wglBeginFrameTrackingI3D = 0;
	wglEndFrameTrackingI3D = 0;
	wglGetFrameUsageI3D = 0;
	wglQueryFrameTrackingI3D = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_DX_interop ******
	isWGL_NV_DX_interop = false;

	wglDXCloseDeviceNV = 0;
	wglDXLockObjectsNV = 0;
	wglDXObjectAccessNV = 0;
	wglDXOpenDeviceNV = 0;
	wglDXRegisterObjectNV = 0;
	wglDXSetResourceShareHandleNV = 0;
	wglDXUnlockObjectsNV = 0;
	wglDXUnregisterObjectNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_DX_interop2 ******
	isWGL_NV_DX_interop2 = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_copy_image ******
	isWGL_NV_copy_image = false;

	wglCopyImageSubDataNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_float_buffer ******
	isWGL_NV_float_buffer = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_gpu_affinity ******
	isWGL_NV_gpu_affinity = false;

	wglCreateAffinityDCNV = 0;
	wglDeleteDCNV = 0;
	wglEnumGpuDevicesNV = 0;
	wglEnumGpusFromAffinityDCNV = 0;
	wglEnumGpusNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_multisample_coverage ******
	isWGL_NV_multisample_coverage = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_present_video ******
	isWGL_NV_present_video = false;

	wglBindVideoDeviceNV = 0;
	wglEnumerateVideoDevicesNV = 0;
	wglQueryCurrentContextNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_render_depth_texture ******
	isWGL_NV_render_depth_texture = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_render_texture_rectangle ******
	isWGL_NV_render_texture_rectangle = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_swap_group ******
	isWGL_NV_swap_group = false;

	wglBindSwapBarrierNV = 0;
	wglJoinSwapGroupNV = 0;
	wglQueryFrameCountNV = 0;
	wglQueryMaxSwapGroupsNV = 0;
	wglQuerySwapGroupNV = 0;
	wglResetFrameCountNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_vertex_array_range ******
	isWGL_NV_vertex_array_range = false;

	wglAllocateMemoryNV = 0;
	wglFreeMemoryNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_video_capture ******
	isWGL_NV_video_capture = false;

	wglBindVideoCaptureDeviceNV = 0;
	wglEnumerateVideoCaptureDevicesNV = 0;
	wglLockVideoCaptureDeviceNV = 0;
	wglQueryVideoCaptureDeviceNV = 0;
	wglReleaseVideoCaptureDeviceNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_video_out ******
	isWGL_NV_video_out = false;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_NV_video_output ******
	isWGL_NV_video_output = false;

	wglBindVideoImageNV = 0;
	wglGetVideoDeviceNV = 0;
	wglGetVideoInfoNV = 0;
	wglReleaseVideoDeviceNV = 0;
	wglReleaseVideoImageNV = 0;
	wglSendPbufferToVideoNV = 0;
#endif //WIN32

#ifdef WIN32
	// ****** WGL_OML_sync_control ******
	isWGL_OML_sync_control = false;

	wglGetMscRateOML = 0;
	wglGetSyncValuesOML = 0;
	wglSwapBuffersMscOML = 0;
	wglSwapLayerBuffersMscOML = 0;
	wglWaitForMscOML = 0;
	wglWaitForSbcOML = 0;
#endif //WIN32

} // clear()


void OpenGLExtensionsGen::initialize()
{
	assert( m_initializedExtensionCount		== 0	&& "call clear() before initialize()" );
	assert( m_initializedProcCount			== 0	&& "call clear() before initialize()" );
	assert( m_initializedExtensions.size()	== 0	&& "call clear() before initialize()" );

	// Statistics
	std::vector< std::string > extensions	= getExtensionsVector();
	std::vector< std::string > wextensions	= getWExtensionsVector();

	// *** Informations from drivers ***
	logEndl("Drivers informations :");
	logEndl( getInformations( 3 ) );
	logEndl("");

	// *** Informations from gle ***
	logEndl("gle detailed informations :");

	// Initializes extension groups

	initializeGLX_3DFX();
	initializeGLX_AMD();
	initializeGLX_ARB();
	initializeGLX_EXT();
	initializeGLX_INTEL();
	initializeGLX_MESA();
	initializeGLX_NV();
	initializeGLX_OML();
	initializeGLX_SGI();
	initializeGLX_SGIS();
	initializeGLX_SGIX();
	initializeGLX_SUN();
	initializeGLX_VERSION();
	initializeGL_3DFX();
	initializeGL_AMD();
	initializeGL_APPLE();
	initializeGL_ARB();
	initializeGL_ATI();
	initializeGL_EXT();
	initializeGL_FfdMaskSGIX();
	initializeGL_GREMEDY();
	initializeGL_HP();
	initializeGL_IBM();
	initializeGL_INGR();
	initializeGL_INTEL();
	initializeGL_KHR();
	initializeGL_MESA();
	initializeGL_MESAX();
	initializeGL_NV();
	initializeGL_NVX();
	initializeGL_OES();
	initializeGL_OML();
	initializeGL_PGI();
	initializeGL_REND();
	initializeGL_S3();
	initializeGL_SGI();
	initializeGL_SGIS();
	initializeGL_SGIX();
	initializeGL_SUN();
	initializeGL_SUNX();
	initializeGL_VERSION();
	initializeGL_WIN();
	initializeWGL_3DFX();
	initializeWGL_3DL();
	initializeWGL_AMD();
	initializeWGL_ARB();
	initializeWGL_ATI();
	initializeWGL_EXT();
	initializeWGL_I3D();
	initializeWGL_NV();
	initializeWGL_OML();

	// Last part of informations
	logEndl("");
	logEndl("gle informations :");
	
	std::stringstream strStream;
	strStream << m_initializedExtensionCount << "/" << m_supportedExtensionCount << " extensions initialized, ";
	strStream << m_initializedProcCount << "/" << m_supportedProcCount << " procedure pointers initialized." << std::ends;
	logEndl( strStream.str() );

	std::stringstream strStream2;
	strStream2 << m_initializedExtensionCount << "/" << static_cast<int>(extensions.size() + wextensions.size());
	strStream2 << " (" << 100.f * static_cast<float>(m_initializedExtensionCount)/static_cast<float>(extensions.size() + wextensions.size());
	strStream2 << "%) extensions initialized." << std::ends;
	logEndl( strStream2.str() );

	// gleInitializedExtensions
	std::vector< std::string > gleInitializedExtensions( m_initializedExtensions );
	
	std::stable_sort( gleInitializedExtensions.begin(), gleInitializedExtensions.end() );

	logEndl("Initialized extensions :");
	log( gleInitializedExtensions );
	logEndl("");

	// driversAllExtensions
	std::vector< std::string > driversAllExtensions( getExtensionsVector() );
	std::vector< std::string > driversWExtensions(	getWExtensionsVector() );
	driversAllExtensions.insert( driversAllExtensions.end(), driversWExtensions.begin(), driversWExtensions.end() );

	std::stable_sort( driversAllExtensions.begin(), driversAllExtensions.end() );
	
	// difference.
	logEndl("Extensions not initialized but exposed by drivers (should be empty :)");

	std::vector< std::string >	difference;
	
	std::insert_iterator< std::vector< std::string > > differenceInserter( difference, difference.begin() );
	
	std::set_difference(	driversAllExtensions.begin(), driversAllExtensions.end(),
								gleInitializedExtensions.begin(), gleInitializedExtensions.end(),
								differenceInserter );
								
	log( difference );
	logEndl("");
} // initialize


void OpenGLExtensionsGen::initializeGLX_3DFX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_3DFX_multisample ******

	isGLX_3DFX_multisample = isWExtensionSupported("GLX_3DFX_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_3DFX_multisample )
	{
		std::stringstream strStream;
		strStream << "GLX_3DFX_multisample                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_3DFX_multisample                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_3DFX_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_3DFX_multisample                              : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_3DFX_multisample()


void OpenGLExtensionsGen::initializeGLX_AMD()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_AMD_gpu_association ******

	isGLX_AMD_gpu_association = isWExtensionSupported("GLX_AMD_gpu_association");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_AMD_gpu_association )
	{
		std::stringstream strStream;
		strStream << "GLX_AMD_gpu_association                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_AMD_gpu_association                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_AMD_gpu_association") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_AMD_gpu_association                           : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_AMD_gpu_association()


void OpenGLExtensionsGen::initializeGLX_ARB()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_ARB_create_context ******

	isGLX_ARB_create_context = isWExtensionSupported("GLX_ARB_create_context");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_create_context ) // || isSEDEnable()
	{
		glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC) getExtensionPtr( "glXCreateContextAttribsARB" );
		if ( glXCreateContextAttribsARB != 0 )	++localInitializedProcCount;

	} // if ( isGLX_ARB_create_context )

	if ( isGLX_ARB_create_context )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_create_context                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_create_context                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_create_context") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_create_context                            : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_create_context_profile ******

	isGLX_ARB_create_context_profile = isWExtensionSupported("GLX_ARB_create_context_profile");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_create_context_profile )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_create_context_profile                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_create_context_profile                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_create_context_profile") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_create_context_profile                    : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_create_context_robustness ******

	isGLX_ARB_create_context_robustness = isWExtensionSupported("GLX_ARB_create_context_robustness");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_create_context_robustness )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_create_context_robustness                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_create_context_robustness                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_create_context_robustness") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_create_context_robustness                 : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_fbconfig_float ******

	isGLX_ARB_fbconfig_float = isWExtensionSupported("GLX_ARB_fbconfig_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_fbconfig_float )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_fbconfig_float                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_fbconfig_float                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_fbconfig_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_fbconfig_float                            : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_framebuffer_sRGB ******

	isGLX_ARB_framebuffer_sRGB = isWExtensionSupported("GLX_ARB_framebuffer_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_framebuffer_sRGB )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_framebuffer_sRGB                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_framebuffer_sRGB                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_framebuffer_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_framebuffer_sRGB                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_get_proc_address ******

	isGLX_ARB_get_proc_address = isWExtensionSupported("GLX_ARB_get_proc_address");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_get_proc_address ) // || isSEDEnable()
	{
		glXGetProcAddressARB = (PFNGLXGETPROCADDRESSARBPROC) getExtensionPtr( "glXGetProcAddressARB" );
		if ( glXGetProcAddressARB != 0 )	++localInitializedProcCount;

	} // if ( isGLX_ARB_get_proc_address )

	if ( isGLX_ARB_get_proc_address )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_get_proc_address                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_get_proc_address                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_get_proc_address") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_get_proc_address                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_multisample ******

	isGLX_ARB_multisample = isWExtensionSupported("GLX_ARB_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_multisample )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_multisample                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_multisample                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_multisample                               : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_ARB_vertex_buffer_object ******

	isGLX_ARB_vertex_buffer_object = isWExtensionSupported("GLX_ARB_vertex_buffer_object");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_ARB_vertex_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GLX_ARB_vertex_buffer_object                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_ARB_vertex_buffer_object                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_ARB_vertex_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_ARB_vertex_buffer_object                      : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_ARB_vertex_buffer_object()


void OpenGLExtensionsGen::initializeGLX_EXT()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_EXT_buffer_age ******

	isGLX_EXT_buffer_age = isWExtensionSupported("GLX_EXT_buffer_age");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_buffer_age )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_buffer_age                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_buffer_age                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_buffer_age") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_buffer_age                                : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_create_context_es2_profile ******

	isGLX_EXT_create_context_es2_profile = isWExtensionSupported("GLX_EXT_create_context_es2_profile");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_create_context_es2_profile )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_create_context_es2_profile                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_create_context_es2_profile                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_create_context_es2_profile") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_create_context_es2_profile                : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_create_context_es_profile ******

	isGLX_EXT_create_context_es_profile = isWExtensionSupported("GLX_EXT_create_context_es_profile");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_create_context_es_profile )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_create_context_es_profile                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_create_context_es_profile                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_create_context_es_profile") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_create_context_es_profile                 : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_fbconfig_packed_float ******

	isGLX_EXT_fbconfig_packed_float = isWExtensionSupported("GLX_EXT_fbconfig_packed_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_fbconfig_packed_float )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_fbconfig_packed_float                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_fbconfig_packed_float                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_fbconfig_packed_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_fbconfig_packed_float                     : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_framebuffer_sRGB ******

	isGLX_EXT_framebuffer_sRGB = isWExtensionSupported("GLX_EXT_framebuffer_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_framebuffer_sRGB )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_framebuffer_sRGB                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_framebuffer_sRGB                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_framebuffer_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_framebuffer_sRGB                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_import_context ******

	isGLX_EXT_import_context = isWExtensionSupported("GLX_EXT_import_context");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_import_context ) // || isSEDEnable()
	{
		glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC) getExtensionPtr( "glXFreeContextEXT" );
		if ( glXFreeContextEXT != 0 )	++localInitializedProcCount;

		glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC) getExtensionPtr( "glXGetContextIDEXT" );
		if ( glXGetContextIDEXT != 0 )	++localInitializedProcCount;

		glXGetCurrentDisplayEXT = (PFNGLXGETCURRENTDISPLAYEXTPROC) getExtensionPtr( "glXGetCurrentDisplayEXT" );
		if ( glXGetCurrentDisplayEXT != 0 )	++localInitializedProcCount;

		glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC) getExtensionPtr( "glXImportContextEXT" );
		if ( glXImportContextEXT != 0 )	++localInitializedProcCount;

		glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC) getExtensionPtr( "glXQueryContextInfoEXT" );
		if ( glXQueryContextInfoEXT != 0 )	++localInitializedProcCount;

	} // if ( isGLX_EXT_import_context )

	if ( isGLX_EXT_import_context )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_import_context                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_import_context                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_import_context") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_import_context                            : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_swap_control ******

	isGLX_EXT_swap_control = isWExtensionSupported("GLX_EXT_swap_control");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_swap_control ) // || isSEDEnable()
	{
		glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) getExtensionPtr( "glXSwapIntervalEXT" );
		if ( glXSwapIntervalEXT != 0 )	++localInitializedProcCount;

	} // if ( isGLX_EXT_swap_control )

	if ( isGLX_EXT_swap_control )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_swap_control                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_swap_control                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_swap_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_swap_control                              : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_swap_control_tear ******

	isGLX_EXT_swap_control_tear = isWExtensionSupported("GLX_EXT_swap_control_tear");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_swap_control_tear )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_swap_control_tear                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_swap_control_tear                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_swap_control_tear") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_swap_control_tear                         : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_texture_from_pixmap ******

	isGLX_EXT_texture_from_pixmap = isWExtensionSupported("GLX_EXT_texture_from_pixmap");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_texture_from_pixmap ) // || isSEDEnable()
	{
		glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC) getExtensionPtr( "glXBindTexImageEXT" );
		if ( glXBindTexImageEXT != 0 )	++localInitializedProcCount;

		glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC) getExtensionPtr( "glXReleaseTexImageEXT" );
		if ( glXReleaseTexImageEXT != 0 )	++localInitializedProcCount;

	} // if ( isGLX_EXT_texture_from_pixmap )

	if ( isGLX_EXT_texture_from_pixmap )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_texture_from_pixmap                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_texture_from_pixmap                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_texture_from_pixmap") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_texture_from_pixmap                       : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_visual_info ******

	isGLX_EXT_visual_info = isWExtensionSupported("GLX_EXT_visual_info");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_visual_info )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_visual_info                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_visual_info                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_visual_info") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_visual_info                               : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_EXT_visual_rating ******

	isGLX_EXT_visual_rating = isWExtensionSupported("GLX_EXT_visual_rating");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_EXT_visual_rating )
	{
		std::stringstream strStream;
		strStream << "GLX_EXT_visual_rating                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_EXT_visual_rating                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_EXT_visual_rating") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_EXT_visual_rating                             : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_EXT_visual_rating()


void OpenGLExtensionsGen::initializeGLX_INTEL()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_INTEL_swap_event ******

	isGLX_INTEL_swap_event = isWExtensionSupported("GLX_INTEL_swap_event");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_INTEL_swap_event )
	{
		std::stringstream strStream;
		strStream << "GLX_INTEL_swap_event                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_INTEL_swap_event                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_INTEL_swap_event") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_INTEL_swap_event                              : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_INTEL_swap_event()


void OpenGLExtensionsGen::initializeGLX_MESA()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_MESA_agp_offset ******

	isGLX_MESA_agp_offset = isWExtensionSupported("GLX_MESA_agp_offset");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_MESA_agp_offset ) // || isSEDEnable()
	{
		glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC) getExtensionPtr( "glXGetAGPOffsetMESA" );
		if ( glXGetAGPOffsetMESA != 0 )	++localInitializedProcCount;

	} // if ( isGLX_MESA_agp_offset )

	if ( isGLX_MESA_agp_offset )
	{
		std::stringstream strStream;
		strStream << "GLX_MESA_agp_offset                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_MESA_agp_offset                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_MESA_agp_offset") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_MESA_agp_offset                               : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_MESA_copy_sub_buffer ******

	isGLX_MESA_copy_sub_buffer = isWExtensionSupported("GLX_MESA_copy_sub_buffer");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_MESA_copy_sub_buffer ) // || isSEDEnable()
	{
		glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC) getExtensionPtr( "glXCopySubBufferMESA" );
		if ( glXCopySubBufferMESA != 0 )	++localInitializedProcCount;

	} // if ( isGLX_MESA_copy_sub_buffer )

	if ( isGLX_MESA_copy_sub_buffer )
	{
		std::stringstream strStream;
		strStream << "GLX_MESA_copy_sub_buffer                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_MESA_copy_sub_buffer                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_MESA_copy_sub_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_MESA_copy_sub_buffer                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_MESA_pixmap_colormap ******

	isGLX_MESA_pixmap_colormap = isWExtensionSupported("GLX_MESA_pixmap_colormap");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_MESA_pixmap_colormap ) // || isSEDEnable()
	{
		glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC) getExtensionPtr( "glXCreateGLXPixmapMESA" );
		if ( glXCreateGLXPixmapMESA != 0 )	++localInitializedProcCount;

	} // if ( isGLX_MESA_pixmap_colormap )

	if ( isGLX_MESA_pixmap_colormap )
	{
		std::stringstream strStream;
		strStream << "GLX_MESA_pixmap_colormap                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_MESA_pixmap_colormap                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_MESA_pixmap_colormap") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_MESA_pixmap_colormap                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_MESA_release_buffers ******

	isGLX_MESA_release_buffers = isWExtensionSupported("GLX_MESA_release_buffers");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_MESA_release_buffers ) // || isSEDEnable()
	{
		glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC) getExtensionPtr( "glXReleaseBuffersMESA" );
		if ( glXReleaseBuffersMESA != 0 )	++localInitializedProcCount;

	} // if ( isGLX_MESA_release_buffers )

	if ( isGLX_MESA_release_buffers )
	{
		std::stringstream strStream;
		strStream << "GLX_MESA_release_buffers                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_MESA_release_buffers                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_MESA_release_buffers") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_MESA_release_buffers                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_MESA_set_3dfx_mode ******

	isGLX_MESA_set_3dfx_mode = isWExtensionSupported("GLX_MESA_set_3dfx_mode");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_MESA_set_3dfx_mode ) // || isSEDEnable()
	{
		glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC) getExtensionPtr( "glXSet3DfxModeMESA" );
		if ( glXSet3DfxModeMESA != 0 )	++localInitializedProcCount;

	} // if ( isGLX_MESA_set_3dfx_mode )

	if ( isGLX_MESA_set_3dfx_mode )
	{
		std::stringstream strStream;
		strStream << "GLX_MESA_set_3dfx_mode                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_MESA_set_3dfx_mode                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_MESA_set_3dfx_mode") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_MESA_set_3dfx_mode                            : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_MESA_set_3dfx_mode()


void OpenGLExtensionsGen::initializeGLX_NV()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_NV_copy_image ******

	isGLX_NV_copy_image = isWExtensionSupported("GLX_NV_copy_image");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_copy_image ) // || isSEDEnable()
	{
		glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC) getExtensionPtr( "glXCopyImageSubDataNV" );
		if ( glXCopyImageSubDataNV != 0 )	++localInitializedProcCount;

	} // if ( isGLX_NV_copy_image )

	if ( isGLX_NV_copy_image )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_copy_image                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_copy_image                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_copy_image") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_copy_image                                 : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_float_buffer ******

	isGLX_NV_float_buffer = isWExtensionSupported("GLX_NV_float_buffer");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_float_buffer )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_float_buffer                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_float_buffer                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_float_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_float_buffer                               : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_multisample_coverage ******

	isGLX_NV_multisample_coverage = isWExtensionSupported("GLX_NV_multisample_coverage");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_multisample_coverage )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_multisample_coverage                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_multisample_coverage                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_multisample_coverage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_multisample_coverage                       : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_present_video ******

	isGLX_NV_present_video = isWExtensionSupported("GLX_NV_present_video");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_present_video ) // || isSEDEnable()
	{
		glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC) getExtensionPtr( "glXBindVideoDeviceNV" );
		if ( glXBindVideoDeviceNV != 0 )	++localInitializedProcCount;

		glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC) getExtensionPtr( "glXEnumerateVideoDevicesNV" );
		if ( glXEnumerateVideoDevicesNV != 0 )	++localInitializedProcCount;

	} // if ( isGLX_NV_present_video )

	if ( isGLX_NV_present_video )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_present_video                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_present_video                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_present_video") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_present_video                              : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_swap_group ******

	isGLX_NV_swap_group = isWExtensionSupported("GLX_NV_swap_group");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_swap_group ) // || isSEDEnable()
	{
		glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC) getExtensionPtr( "glXBindSwapBarrierNV" );
		if ( glXBindSwapBarrierNV != 0 )	++localInitializedProcCount;

		glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC) getExtensionPtr( "glXJoinSwapGroupNV" );
		if ( glXJoinSwapGroupNV != 0 )	++localInitializedProcCount;

		glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC) getExtensionPtr( "glXQueryFrameCountNV" );
		if ( glXQueryFrameCountNV != 0 )	++localInitializedProcCount;

		glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC) getExtensionPtr( "glXQueryMaxSwapGroupsNV" );
		if ( glXQueryMaxSwapGroupsNV != 0 )	++localInitializedProcCount;

		glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC) getExtensionPtr( "glXQuerySwapGroupNV" );
		if ( glXQuerySwapGroupNV != 0 )	++localInitializedProcCount;

		glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC) getExtensionPtr( "glXResetFrameCountNV" );
		if ( glXResetFrameCountNV != 0 )	++localInitializedProcCount;

	} // if ( isGLX_NV_swap_group )

	if ( isGLX_NV_swap_group )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_swap_group                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_swap_group                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_swap_group") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_swap_group                                 : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_video_capture ******

	isGLX_NV_video_capture = isWExtensionSupported("GLX_NV_video_capture");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_video_capture ) // || isSEDEnable()
	{
		glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "glXBindVideoCaptureDeviceNV" );
		if ( glXBindVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

		glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC) getExtensionPtr( "glXEnumerateVideoCaptureDevicesNV" );
		if ( glXEnumerateVideoCaptureDevicesNV != 0 )	++localInitializedProcCount;

		glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "glXLockVideoCaptureDeviceNV" );
		if ( glXLockVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

		glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "glXQueryVideoCaptureDeviceNV" );
		if ( glXQueryVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

		glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "glXReleaseVideoCaptureDeviceNV" );
		if ( glXReleaseVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

	} // if ( isGLX_NV_video_capture )

	if ( isGLX_NV_video_capture )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_video_capture                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_video_capture                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_video_capture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_video_capture                              : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_video_out ******

	isGLX_NV_video_out = isWExtensionSupported("GLX_NV_video_out");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_video_out )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_video_out                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_video_out                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_video_out") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_video_out                                  : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_NV_video_output ******

	isGLX_NV_video_output = isWExtensionSupported("GLX_NV_video_output");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGLX_NV_video_output ) // || isSEDEnable()
	{
		glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC) getExtensionPtr( "glXBindVideoImageNV" );
		if ( glXBindVideoImageNV != 0 )	++localInitializedProcCount;

		glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC) getExtensionPtr( "glXGetVideoDeviceNV" );
		if ( glXGetVideoDeviceNV != 0 )	++localInitializedProcCount;

		glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC) getExtensionPtr( "glXGetVideoInfoNV" );
		if ( glXGetVideoInfoNV != 0 )	++localInitializedProcCount;

		glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC) getExtensionPtr( "glXReleaseVideoDeviceNV" );
		if ( glXReleaseVideoDeviceNV != 0 )	++localInitializedProcCount;

		glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC) getExtensionPtr( "glXReleaseVideoImageNV" );
		if ( glXReleaseVideoImageNV != 0 )	++localInitializedProcCount;

		glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC) getExtensionPtr( "glXSendPbufferToVideoNV" );
		if ( glXSendPbufferToVideoNV != 0 )	++localInitializedProcCount;

	} // if ( isGLX_NV_video_output )

	if ( isGLX_NV_video_output )
	{
		std::stringstream strStream;
		strStream << "GLX_NV_video_output                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_NV_video_output                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_NV_video_output") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_NV_video_output                               : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_NV_video_output()


void OpenGLExtensionsGen::initializeGLX_OML()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_OML_swap_method ******

	isGLX_OML_swap_method = isWExtensionSupported("GLX_OML_swap_method");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_OML_swap_method )
	{
		std::stringstream strStream;
		strStream << "GLX_OML_swap_method                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_OML_swap_method                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_OML_swap_method") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_OML_swap_method                               : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_OML_sync_control ******

	isGLX_OML_sync_control = isWExtensionSupported("GLX_OML_sync_control");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGLX_OML_sync_control ) // || isSEDEnable()
	{
		glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC) getExtensionPtr( "glXGetMscRateOML" );
		if ( glXGetMscRateOML != 0 )	++localInitializedProcCount;

		glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC) getExtensionPtr( "glXGetSyncValuesOML" );
		if ( glXGetSyncValuesOML != 0 )	++localInitializedProcCount;

		glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC) getExtensionPtr( "glXSwapBuffersMscOML" );
		if ( glXSwapBuffersMscOML != 0 )	++localInitializedProcCount;

		glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC) getExtensionPtr( "glXWaitForMscOML" );
		if ( glXWaitForMscOML != 0 )	++localInitializedProcCount;

		glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC) getExtensionPtr( "glXWaitForSbcOML" );
		if ( glXWaitForSbcOML != 0 )	++localInitializedProcCount;

	} // if ( isGLX_OML_sync_control )

	if ( isGLX_OML_sync_control )
	{
		std::stringstream strStream;
		strStream << "GLX_OML_sync_control                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_OML_sync_control                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_OML_sync_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_OML_sync_control                              : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_OML_sync_control()


void OpenGLExtensionsGen::initializeGLX_SGI()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_SGI_cushion ******

	isGLX_SGI_cushion = isWExtensionSupported("GLX_SGI_cushion");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_SGI_cushion ) // || isSEDEnable()
	{
		glXCushionSGI = (PFNGLXCUSHIONSGIPROC) getExtensionPtr( "glXCushionSGI" );
		if ( glXCushionSGI != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGI_cushion )

	if ( isGLX_SGI_cushion )
	{
		std::stringstream strStream;
		strStream << "GLX_SGI_cushion                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGI_cushion                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGI_cushion") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGI_cushion                                   : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGI_make_current_read ******

	isGLX_SGI_make_current_read = isWExtensionSupported("GLX_SGI_make_current_read");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGLX_SGI_make_current_read ) // || isSEDEnable()
	{
		glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC) getExtensionPtr( "glXGetCurrentReadDrawableSGI" );
		if ( glXGetCurrentReadDrawableSGI != 0 )	++localInitializedProcCount;

		glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC) getExtensionPtr( "glXMakeCurrentReadSGI" );
		if ( glXMakeCurrentReadSGI != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGI_make_current_read )

	if ( isGLX_SGI_make_current_read )
	{
		std::stringstream strStream;
		strStream << "GLX_SGI_make_current_read                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGI_make_current_read                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGI_make_current_read") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGI_make_current_read                         : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGI_swap_control ******

	isGLX_SGI_swap_control = isWExtensionSupported("GLX_SGI_swap_control");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_SGI_swap_control ) // || isSEDEnable()
	{
		glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) getExtensionPtr( "glXSwapIntervalSGI" );
		if ( glXSwapIntervalSGI != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGI_swap_control )

	if ( isGLX_SGI_swap_control )
	{
		std::stringstream strStream;
		strStream << "GLX_SGI_swap_control                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGI_swap_control                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGI_swap_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGI_swap_control                              : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGI_video_sync ******

	isGLX_SGI_video_sync = isWExtensionSupported("GLX_SGI_video_sync");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGLX_SGI_video_sync ) // || isSEDEnable()
	{
		glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC) getExtensionPtr( "glXGetVideoSyncSGI" );
		if ( glXGetVideoSyncSGI != 0 )	++localInitializedProcCount;

		glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC) getExtensionPtr( "glXWaitVideoSyncSGI" );
		if ( glXWaitVideoSyncSGI != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGI_video_sync )

	if ( isGLX_SGI_video_sync )
	{
		std::stringstream strStream;
		strStream << "GLX_SGI_video_sync                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGI_video_sync                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGI_video_sync") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGI_video_sync                                : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_SGI_video_sync()


void OpenGLExtensionsGen::initializeGLX_SGIS()
{
/*	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_SGIS_blended_overlay ******

	isGLX_SGIS_blended_overlay = isWExtensionSupported("GLX_SGIS_blended_overlay");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIS_blended_overlay )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIS_blended_overlay                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIS_blended_overlay                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIS_blended_overlay") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIS_blended_overlay                          : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIS_multisample ******

	isGLX_SGIS_multisample = isWExtensionSupported("GLX_SGIS_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIS_multisample )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIS_multisample                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIS_multisample                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIS_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIS_multisample                              : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIS_shared_multisample ******

	isGLX_SGIS_shared_multisample = isWExtensionSupported("GLX_SGIS_shared_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIS_shared_multisample )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIS_shared_multisample                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIS_shared_multisample                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIS_shared_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIS_shared_multisample                       : not detected." );
	}


#endif // ifdef POSIX
*/
} // initializeGLX_SGIS_shared_multisample()


void OpenGLExtensionsGen::initializeGLX_SGIX()
{
/*	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_SGIX_dmbuffer ******

	isGLX_SGIX_dmbuffer = isWExtensionSupported("GLX_SGIX_dmbuffer");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_dmbuffer ) // || isSEDEnable()
	{
		glXAssociateDMPbufferSGIX = (PFNGLXASSOCIATEDMPBUFFERSGIXPROC) getExtensionPtr( "glXAssociateDMPbufferSGIX" );
		if ( glXAssociateDMPbufferSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_dmbuffer )

	if ( isGLX_SGIX_dmbuffer )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_dmbuffer                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_dmbuffer                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_dmbuffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_dmbuffer                                 : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_fbconfig ******

	isGLX_SGIX_fbconfig = isWExtensionSupported("GLX_SGIX_fbconfig");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_fbconfig ) // || isSEDEnable()
	{
		glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC) getExtensionPtr( "glXChooseFBConfigSGIX" );
		if ( glXChooseFBConfigSGIX != 0 )	++localInitializedProcCount;

		glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) getExtensionPtr( "glXCreateContextWithConfigSGIX" );
		if ( glXCreateContextWithConfigSGIX != 0 )	++localInitializedProcCount;

		glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) getExtensionPtr( "glXCreateGLXPixmapWithConfigSGIX" );
		if ( glXCreateGLXPixmapWithConfigSGIX != 0 )	++localInitializedProcCount;

		glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC) getExtensionPtr( "glXGetFBConfigAttribSGIX" );
		if ( glXGetFBConfigAttribSGIX != 0 )	++localInitializedProcCount;

		glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) getExtensionPtr( "glXGetFBConfigFromVisualSGIX" );
		if ( glXGetFBConfigFromVisualSGIX != 0 )	++localInitializedProcCount;

		glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) getExtensionPtr( "glXGetVisualFromFBConfigSGIX" );
		if ( glXGetVisualFromFBConfigSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_fbconfig )

	if ( isGLX_SGIX_fbconfig )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_fbconfig                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_fbconfig                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_fbconfig") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_fbconfig                                 : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_hyperpipe ******

	isGLX_SGIX_hyperpipe = isWExtensionSupported("GLX_SGIX_hyperpipe");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_hyperpipe ) // || isSEDEnable()
	{
		glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC) getExtensionPtr( "glXBindHyperpipeSGIX" );
		if ( glXBindHyperpipeSGIX != 0 )	++localInitializedProcCount;

		glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) getExtensionPtr( "glXDestroyHyperpipeConfigSGIX" );
		if ( glXDestroyHyperpipeConfigSGIX != 0 )	++localInitializedProcCount;

		glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC) getExtensionPtr( "glXHyperpipeAttribSGIX" );
		if ( glXHyperpipeAttribSGIX != 0 )	++localInitializedProcCount;

		glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC) getExtensionPtr( "glXHyperpipeConfigSGIX" );
		if ( glXHyperpipeConfigSGIX != 0 )	++localInitializedProcCount;

		glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) getExtensionPtr( "glXQueryHyperpipeAttribSGIX" );
		if ( glXQueryHyperpipeAttribSGIX != 0 )	++localInitializedProcCount;

		glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) getExtensionPtr( "glXQueryHyperpipeBestAttribSGIX" );
		if ( glXQueryHyperpipeBestAttribSGIX != 0 )	++localInitializedProcCount;

		glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC) getExtensionPtr( "glXQueryHyperpipeConfigSGIX" );
		if ( glXQueryHyperpipeConfigSGIX != 0 )	++localInitializedProcCount;

		glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC) getExtensionPtr( "glXQueryHyperpipeNetworkSGIX" );
		if ( glXQueryHyperpipeNetworkSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_hyperpipe )

	if ( isGLX_SGIX_hyperpipe )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_hyperpipe                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_hyperpipe                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_hyperpipe") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_hyperpipe                                : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_pbuffer ******

	isGLX_SGIX_pbuffer = isWExtensionSupported("GLX_SGIX_pbuffer");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_pbuffer ) // || isSEDEnable()
	{
		glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC) getExtensionPtr( "glXCreateGLXPbufferSGIX" );
		if ( glXCreateGLXPbufferSGIX != 0 )	++localInitializedProcCount;

		glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC) getExtensionPtr( "glXDestroyGLXPbufferSGIX" );
		if ( glXDestroyGLXPbufferSGIX != 0 )	++localInitializedProcCount;

		glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC) getExtensionPtr( "glXGetSelectedEventSGIX" );
		if ( glXGetSelectedEventSGIX != 0 )	++localInitializedProcCount;

		glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC) getExtensionPtr( "glXQueryGLXPbufferSGIX" );
		if ( glXQueryGLXPbufferSGIX != 0 )	++localInitializedProcCount;

		glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC) getExtensionPtr( "glXSelectEventSGIX" );
		if ( glXSelectEventSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_pbuffer )

	if ( isGLX_SGIX_pbuffer )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_pbuffer                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_pbuffer                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_pbuffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_pbuffer                                  : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_swap_barrier ******

	isGLX_SGIX_swap_barrier = isWExtensionSupported("GLX_SGIX_swap_barrier");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_swap_barrier ) // || isSEDEnable()
	{
		glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC) getExtensionPtr( "glXBindSwapBarrierSGIX" );
		if ( glXBindSwapBarrierSGIX != 0 )	++localInitializedProcCount;

		glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) getExtensionPtr( "glXQueryMaxSwapBarriersSGIX" );
		if ( glXQueryMaxSwapBarriersSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_swap_barrier )

	if ( isGLX_SGIX_swap_barrier )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_swap_barrier                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_swap_barrier                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_swap_barrier") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_swap_barrier                             : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_swap_group ******

	isGLX_SGIX_swap_group = isWExtensionSupported("GLX_SGIX_swap_group");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_swap_group ) // || isSEDEnable()
	{
		glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC) getExtensionPtr( "glXJoinSwapGroupSGIX" );
		if ( glXJoinSwapGroupSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_swap_group )

	if ( isGLX_SGIX_swap_group )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_swap_group                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_swap_group                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_swap_group") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_swap_group                               : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_video_resize ******

	isGLX_SGIX_video_resize = isWExtensionSupported("GLX_SGIX_video_resize");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_video_resize ) // || isSEDEnable()
	{
		glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC) getExtensionPtr( "glXBindChannelToWindowSGIX" );
		if ( glXBindChannelToWindowSGIX != 0 )	++localInitializedProcCount;

		glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC) getExtensionPtr( "glXChannelRectSGIX" );
		if ( glXChannelRectSGIX != 0 )	++localInitializedProcCount;

		glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC) getExtensionPtr( "glXChannelRectSyncSGIX" );
		if ( glXChannelRectSyncSGIX != 0 )	++localInitializedProcCount;

		glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC) getExtensionPtr( "glXQueryChannelDeltasSGIX" );
		if ( glXQueryChannelDeltasSGIX != 0 )	++localInitializedProcCount;

		glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC) getExtensionPtr( "glXQueryChannelRectSGIX" );
		if ( glXQueryChannelRectSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_video_resize )

	if ( isGLX_SGIX_video_resize )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_video_resize                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_video_resize                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_video_resize") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_video_resize                             : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_video_source ******

	isGLX_SGIX_video_source = isWExtensionSupported("GLX_SGIX_video_source");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_video_source ) // || isSEDEnable()
	{
		glXCreateGLXVideoSourceSGIX = (PFNGLXCREATEGLXVIDEOSOURCESGIXPROC) getExtensionPtr( "glXCreateGLXVideoSourceSGIX" );
		if ( glXCreateGLXVideoSourceSGIX != 0 )	++localInitializedProcCount;

		glXDestroyGLXVideoSourceSGIX = (PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC) getExtensionPtr( "glXDestroyGLXVideoSourceSGIX" );
		if ( glXDestroyGLXVideoSourceSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SGIX_video_source )

	if ( isGLX_SGIX_video_source )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_video_source                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_video_source                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_video_source") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_video_source                             : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_SGIX_visual_select_group ******

	isGLX_SGIX_visual_select_group = isWExtensionSupported("GLX_SGIX_visual_select_group");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGLX_SGIX_visual_select_group )
	{
		std::stringstream strStream;
		strStream << "GLX_SGIX_visual_select_group                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SGIX_visual_select_group                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SGIX_visual_select_group") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SGIX_visual_select_group                      : not detected." );
	}


#endif // ifdef POSIX
*/
} // initializeGLX_SGIX_visual_select_group()


void OpenGLExtensionsGen::initializeGLX_SUN()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_SUN_get_transparent_index ******

	isGLX_SUN_get_transparent_index = isWExtensionSupported("GLX_SUN_get_transparent_index");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_SUN_get_transparent_index ) // || isSEDEnable()
	{
		glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC) getExtensionPtr( "glXGetTransparentIndexSUN" );
		if ( glXGetTransparentIndexSUN != 0 )	++localInitializedProcCount;

	} // if ( isGLX_SUN_get_transparent_index )

	if ( isGLX_SUN_get_transparent_index )
	{
		std::stringstream strStream;
		strStream << "GLX_SUN_get_transparent_index                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_SUN_get_transparent_index                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_SUN_get_transparent_index") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_SUN_get_transparent_index                     : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_SUN_get_transparent_index()


void OpenGLExtensionsGen::initializeGLX_VERSION()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef POSIX

	// ****** GLX_VERSION_1_3 ******

	isGLX_VERSION_1_3 = isWExtensionSupported("GLX_VERSION_1_3");

	localSupportedProcCount		= 18;
	localInitializedProcCount	= 0;

	if ( isGLX_VERSION_1_3 ) // || isSEDEnable()
	{
		glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) getExtensionPtr( "glXChooseFBConfig" );
		if ( glXChooseFBConfig != 0 )	++localInitializedProcCount;

		glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC) getExtensionPtr( "glXCreateNewContext" );
		if ( glXCreateNewContext != 0 )	++localInitializedProcCount;

		glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC) getExtensionPtr( "glXCreatePbuffer" );
		if ( glXCreatePbuffer != 0 )	++localInitializedProcCount;

		glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC) getExtensionPtr( "glXCreatePixmap" );
		if ( glXCreatePixmap != 0 )	++localInitializedProcCount;

		glXCreateWindow = (PFNGLXCREATEWINDOWPROC) getExtensionPtr( "glXCreateWindow" );
		if ( glXCreateWindow != 0 )	++localInitializedProcCount;

		glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) getExtensionPtr( "glXDestroyPbuffer" );
		if ( glXDestroyPbuffer != 0 )	++localInitializedProcCount;

		glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC) getExtensionPtr( "glXDestroyPixmap" );
		if ( glXDestroyPixmap != 0 )	++localInitializedProcCount;

		glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC) getExtensionPtr( "glXDestroyWindow" );
		if ( glXDestroyWindow != 0 )	++localInitializedProcCount;

		glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC) getExtensionPtr( "glXGetCurrentDisplay" );
		if ( glXGetCurrentDisplay != 0 )	++localInitializedProcCount;

		glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC) getExtensionPtr( "glXGetCurrentReadDrawable" );
		if ( glXGetCurrentReadDrawable != 0 )	++localInitializedProcCount;

		glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC) getExtensionPtr( "glXGetFBConfigAttrib" );
		if ( glXGetFBConfigAttrib != 0 )	++localInitializedProcCount;

		glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC) getExtensionPtr( "glXGetFBConfigs" );
		if ( glXGetFBConfigs != 0 )	++localInitializedProcCount;

		glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC) getExtensionPtr( "glXGetSelectedEvent" );
		if ( glXGetSelectedEvent != 0 )	++localInitializedProcCount;

		glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC) getExtensionPtr( "glXGetVisualFromFBConfig" );
		if ( glXGetVisualFromFBConfig != 0 )	++localInitializedProcCount;

		glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC) getExtensionPtr( "glXMakeContextCurrent" );
		if ( glXMakeContextCurrent != 0 )	++localInitializedProcCount;

		glXQueryContext = (PFNGLXQUERYCONTEXTPROC) getExtensionPtr( "glXQueryContext" );
		if ( glXQueryContext != 0 )	++localInitializedProcCount;

		glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC) getExtensionPtr( "glXQueryDrawable" );
		if ( glXQueryDrawable != 0 )	++localInitializedProcCount;

		glXSelectEvent = (PFNGLXSELECTEVENTPROC) getExtensionPtr( "glXSelectEvent" );
		if ( glXSelectEvent != 0 )	++localInitializedProcCount;

	} // if ( isGLX_VERSION_1_3 )

	if ( isGLX_VERSION_1_3 )
	{
		std::stringstream strStream;
		strStream << "GLX_VERSION_1_3                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_VERSION_1_3                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_VERSION_1_3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_VERSION_1_3                                   : not detected." );
	}


#endif // ifdef POSIX

#ifdef POSIX

	// ****** GLX_VERSION_1_4 ******

	isGLX_VERSION_1_4 = isWExtensionSupported("GLX_VERSION_1_4");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGLX_VERSION_1_4 ) // || isSEDEnable()
	{
		glXGetProcAddress = (PFNGLXGETPROCADDRESSPROC) getExtensionPtr( "glXGetProcAddress" );
		if ( glXGetProcAddress != 0 )	++localInitializedProcCount;

	} // if ( isGLX_VERSION_1_4 )

	if ( isGLX_VERSION_1_4 )
	{
		std::stringstream strStream;
		strStream << "GLX_VERSION_1_4                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GLX_VERSION_1_4                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GLX_VERSION_1_4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GLX_VERSION_1_4                                   : not detected." );
	}


#endif // ifdef POSIX

} // initializeGLX_VERSION_1_4()


void OpenGLExtensionsGen::initializeGL_3DFX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_3DFX_multisample = isExtensionSupported("GL_3DFX_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_3DFX_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_3DFX_multisample                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_3DFX_multisample                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_3DFX_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_3DFX_multisample                               : not detected." );
	}


	isGL_3DFX_tbuffer = isExtensionSupported("GL_3DFX_tbuffer");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_3DFX_tbuffer ) // || isSEDEnable()
	{
		glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC) getExtensionPtr( "glTbufferMask3DFX" );
		if ( glTbufferMask3DFX != 0 )	++localInitializedProcCount;

	} // if ( isGL_3DFX_tbuffer )

	if ( isGL_3DFX_tbuffer )
	{
		std::stringstream strStream;
		strStream << "GL_3DFX_tbuffer                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_3DFX_tbuffer                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_3DFX_tbuffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_3DFX_tbuffer                                   : not detected." );
	}


	isGL_3DFX_texture_compression_FXT1 = isExtensionSupported("GL_3DFX_texture_compression_FXT1");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_3DFX_texture_compression_FXT1 )
	{
		std::stringstream strStream;
		strStream << "GL_3DFX_texture_compression_FXT1                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_3DFX_texture_compression_FXT1                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_3DFX_texture_compression_FXT1") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_3DFX_texture_compression_FXT1                  : not detected." );
	}


} // initializeGL_3DFX_texture_compression_FXT1()


void OpenGLExtensionsGen::initializeGL_AMD()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_AMD_blend_minmax_factor = isExtensionSupported("GL_AMD_blend_minmax_factor");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_blend_minmax_factor )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_blend_minmax_factor                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_blend_minmax_factor                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_blend_minmax_factor") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_blend_minmax_factor                        : not detected." );
	}


	isGL_AMD_conservative_depth = isExtensionSupported("GL_AMD_conservative_depth");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_conservative_depth )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_conservative_depth                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_conservative_depth                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_conservative_depth") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_conservative_depth                         : not detected." );
	}


	isGL_AMD_debug_output = isExtensionSupported("GL_AMD_debug_output");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_debug_output ) // || isSEDEnable()
	{
		glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC) getExtensionPtr( "glDebugMessageCallbackAMD" );
		if ( glDebugMessageCallbackAMD != 0 )	++localInitializedProcCount;

		glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC) getExtensionPtr( "glDebugMessageEnableAMD" );
		if ( glDebugMessageEnableAMD != 0 )	++localInitializedProcCount;

		glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC) getExtensionPtr( "glDebugMessageInsertAMD" );
		if ( glDebugMessageInsertAMD != 0 )	++localInitializedProcCount;

		glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC) getExtensionPtr( "glGetDebugMessageLogAMD" );
		if ( glGetDebugMessageLogAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_debug_output )

	if ( isGL_AMD_debug_output )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_debug_output                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_debug_output                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_debug_output") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_debug_output                               : not detected." );
	}


	isGL_AMD_depth_clamp_separate = isExtensionSupported("GL_AMD_depth_clamp_separate");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_depth_clamp_separate )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_depth_clamp_separate                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_depth_clamp_separate                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_depth_clamp_separate") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_depth_clamp_separate                       : not detected." );
	}


	isGL_AMD_draw_buffers_blend = isExtensionSupported("GL_AMD_draw_buffers_blend");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_draw_buffers_blend ) // || isSEDEnable()
	{
		glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC) getExtensionPtr( "glBlendEquationIndexedAMD" );
		if ( glBlendEquationIndexedAMD != 0 )	++localInitializedProcCount;

		glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC) getExtensionPtr( "glBlendEquationSeparateIndexedAMD" );
		if ( glBlendEquationSeparateIndexedAMD != 0 )	++localInitializedProcCount;

		glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC) getExtensionPtr( "glBlendFuncIndexedAMD" );
		if ( glBlendFuncIndexedAMD != 0 )	++localInitializedProcCount;

		glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) getExtensionPtr( "glBlendFuncSeparateIndexedAMD" );
		if ( glBlendFuncSeparateIndexedAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_draw_buffers_blend )

	if ( isGL_AMD_draw_buffers_blend )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_draw_buffers_blend                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_draw_buffers_blend                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_draw_buffers_blend") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_draw_buffers_blend                         : not detected." );
	}


	isGL_AMD_multi_draw_indirect = isExtensionSupported("GL_AMD_multi_draw_indirect");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_multi_draw_indirect ) // || isSEDEnable()
	{
		glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC) getExtensionPtr( "glMultiDrawArraysIndirectAMD" );
		if ( glMultiDrawArraysIndirectAMD != 0 )	++localInitializedProcCount;

		glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC) getExtensionPtr( "glMultiDrawElementsIndirectAMD" );
		if ( glMultiDrawElementsIndirectAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_multi_draw_indirect )

	if ( isGL_AMD_multi_draw_indirect )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_multi_draw_indirect                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_multi_draw_indirect                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_multi_draw_indirect") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_multi_draw_indirect                        : not detected." );
	}


	isGL_AMD_name_gen_delete = isExtensionSupported("GL_AMD_name_gen_delete");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_name_gen_delete ) // || isSEDEnable()
	{
		glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC) getExtensionPtr( "glDeleteNamesAMD" );
		if ( glDeleteNamesAMD != 0 )	++localInitializedProcCount;

		glGenNamesAMD = (PFNGLGENNAMESAMDPROC) getExtensionPtr( "glGenNamesAMD" );
		if ( glGenNamesAMD != 0 )	++localInitializedProcCount;

		glIsNameAMD = (PFNGLISNAMEAMDPROC) getExtensionPtr( "glIsNameAMD" );
		if ( glIsNameAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_name_gen_delete )

	if ( isGL_AMD_name_gen_delete )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_name_gen_delete                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_name_gen_delete                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_name_gen_delete") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_name_gen_delete                            : not detected." );
	}


	isGL_AMD_performance_monitor = isExtensionSupported("GL_AMD_performance_monitor");

	localSupportedProcCount		= 11;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_performance_monitor ) // || isSEDEnable()
	{
		glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC) getExtensionPtr( "glBeginPerfMonitorAMD" );
		if ( glBeginPerfMonitorAMD != 0 )	++localInitializedProcCount;

		glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC) getExtensionPtr( "glDeletePerfMonitorsAMD" );
		if ( glDeletePerfMonitorsAMD != 0 )	++localInitializedProcCount;

		glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC) getExtensionPtr( "glEndPerfMonitorAMD" );
		if ( glEndPerfMonitorAMD != 0 )	++localInitializedProcCount;

		glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC) getExtensionPtr( "glGenPerfMonitorsAMD" );
		if ( glGenPerfMonitorsAMD != 0 )	++localInitializedProcCount;

		glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC) getExtensionPtr( "glGetPerfMonitorCounterDataAMD" );
		if ( glGetPerfMonitorCounterDataAMD != 0 )	++localInitializedProcCount;

		glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC) getExtensionPtr( "glGetPerfMonitorCounterInfoAMD" );
		if ( glGetPerfMonitorCounterInfoAMD != 0 )	++localInitializedProcCount;

		glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC) getExtensionPtr( "glGetPerfMonitorCounterStringAMD" );
		if ( glGetPerfMonitorCounterStringAMD != 0 )	++localInitializedProcCount;

		glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC) getExtensionPtr( "glGetPerfMonitorCountersAMD" );
		if ( glGetPerfMonitorCountersAMD != 0 )	++localInitializedProcCount;

		glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC) getExtensionPtr( "glGetPerfMonitorGroupStringAMD" );
		if ( glGetPerfMonitorGroupStringAMD != 0 )	++localInitializedProcCount;

		glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC) getExtensionPtr( "glGetPerfMonitorGroupsAMD" );
		if ( glGetPerfMonitorGroupsAMD != 0 )	++localInitializedProcCount;

		glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC) getExtensionPtr( "glSelectPerfMonitorCountersAMD" );
		if ( glSelectPerfMonitorCountersAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_performance_monitor )

	if ( isGL_AMD_performance_monitor )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_performance_monitor                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_performance_monitor                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_performance_monitor") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_performance_monitor                        : not detected." );
	}


	isGL_AMD_pinned_memory = isExtensionSupported("GL_AMD_pinned_memory");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_pinned_memory )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_pinned_memory                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_pinned_memory                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_pinned_memory") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_pinned_memory                              : not detected." );
	}


	isGL_AMD_query_buffer_object = isExtensionSupported("GL_AMD_query_buffer_object");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_query_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_query_buffer_object                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_query_buffer_object                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_query_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_query_buffer_object                        : not detected." );
	}


	isGL_AMD_sample_positions = isExtensionSupported("GL_AMD_sample_positions");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_sample_positions ) // || isSEDEnable()
	{
		glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC) getExtensionPtr( "glSetMultisamplefvAMD" );
		if ( glSetMultisamplefvAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_sample_positions )

	if ( isGL_AMD_sample_positions )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_sample_positions                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_sample_positions                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_sample_positions") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_sample_positions                           : not detected." );
	}


	isGL_AMD_seamless_cubemap_per_texture = isExtensionSupported("GL_AMD_seamless_cubemap_per_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_seamless_cubemap_per_texture )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_seamless_cubemap_per_texture               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_seamless_cubemap_per_texture               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_seamless_cubemap_per_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_seamless_cubemap_per_texture               : not detected." );
	}


	isGL_AMD_shader_stencil_export = isExtensionSupported("GL_AMD_shader_stencil_export");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_shader_stencil_export )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_shader_stencil_export                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_shader_stencil_export                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_shader_stencil_export") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_shader_stencil_export                      : not detected." );
	}


	isGL_AMD_shader_trinary_minmax = isExtensionSupported("GL_AMD_shader_trinary_minmax");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_shader_trinary_minmax )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_shader_trinary_minmax                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_shader_trinary_minmax                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_shader_trinary_minmax") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_shader_trinary_minmax                      : not detected." );
	}


	isGL_AMD_sparse_texture = isExtensionSupported("GL_AMD_sparse_texture");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_sparse_texture ) // || isSEDEnable()
	{
		glTexStorageSparseAMD = (PFNGLTEXSTORAGESPARSEAMDPROC) getExtensionPtr( "glTexStorageSparseAMD" );
		if ( glTexStorageSparseAMD != 0 )	++localInitializedProcCount;

		glTextureStorageSparseAMD = (PFNGLTEXTURESTORAGESPARSEAMDPROC) getExtensionPtr( "glTextureStorageSparseAMD" );
		if ( glTextureStorageSparseAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_sparse_texture )

	if ( isGL_AMD_sparse_texture )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_sparse_texture                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_sparse_texture                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_sparse_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_sparse_texture                             : not detected." );
	}


	isGL_AMD_stencil_operation_extended = isExtensionSupported("GL_AMD_stencil_operation_extended");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_stencil_operation_extended ) // || isSEDEnable()
	{
		glStencilOpValueAMD = (PFNGLSTENCILOPVALUEAMDPROC) getExtensionPtr( "glStencilOpValueAMD" );
		if ( glStencilOpValueAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_stencil_operation_extended )

	if ( isGL_AMD_stencil_operation_extended )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_stencil_operation_extended                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_stencil_operation_extended                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_stencil_operation_extended") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_stencil_operation_extended                 : not detected." );
	}


	isGL_AMD_texture_texture4 = isExtensionSupported("GL_AMD_texture_texture4");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_texture_texture4 )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_texture_texture4                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_texture_texture4                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_texture_texture4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_texture_texture4                           : not detected." );
	}


	isGL_AMD_transform_feedback3_lines_triangles = isExtensionSupported("GL_AMD_transform_feedback3_lines_triangles");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_transform_feedback3_lines_triangles )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_transform_feedback3_lines_triangles        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_transform_feedback3_lines_triangles        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_transform_feedback3_lines_triangles") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_transform_feedback3_lines_triangles        : not detected." );
	}


	isGL_AMD_vertex_shader_layer = isExtensionSupported("GL_AMD_vertex_shader_layer");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_vertex_shader_layer )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_vertex_shader_layer                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_vertex_shader_layer                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_vertex_shader_layer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_vertex_shader_layer                        : not detected." );
	}


	isGL_AMD_vertex_shader_tesselator = isExtensionSupported("GL_AMD_vertex_shader_tesselator");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_vertex_shader_tesselator ) // || isSEDEnable()
	{
		glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC) getExtensionPtr( "glTessellationFactorAMD" );
		if ( glTessellationFactorAMD != 0 )	++localInitializedProcCount;

		glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC) getExtensionPtr( "glTessellationModeAMD" );
		if ( glTessellationModeAMD != 0 )	++localInitializedProcCount;

	} // if ( isGL_AMD_vertex_shader_tesselator )

	if ( isGL_AMD_vertex_shader_tesselator )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_vertex_shader_tesselator                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_vertex_shader_tesselator                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_vertex_shader_tesselator") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_vertex_shader_tesselator                   : not detected." );
	}


	isGL_AMD_vertex_shader_viewport_index = isExtensionSupported("GL_AMD_vertex_shader_viewport_index");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_AMD_vertex_shader_viewport_index )
	{
		std::stringstream strStream;
		strStream << "GL_AMD_vertex_shader_viewport_index               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_AMD_vertex_shader_viewport_index               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_AMD_vertex_shader_viewport_index") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_AMD_vertex_shader_viewport_index               : not detected." );
	}


} // initializeGL_AMD_vertex_shader_viewport_index()


void OpenGLExtensionsGen::initializeGL_APPLE()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_APPLE_aux_depth_stencil = isExtensionSupported("GL_APPLE_aux_depth_stencil");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_aux_depth_stencil )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_aux_depth_stencil                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_aux_depth_stencil                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_aux_depth_stencil") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_aux_depth_stencil                        : not detected." );
	}


	isGL_APPLE_client_storage = isExtensionSupported("GL_APPLE_client_storage");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_client_storage )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_client_storage                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_client_storage                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_client_storage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_client_storage                           : not detected." );
	}


	isGL_APPLE_element_array = isExtensionSupported("GL_APPLE_element_array");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_element_array ) // || isSEDEnable()
	{
		glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC) getExtensionPtr( "glDrawElementArrayAPPLE" );
		if ( glDrawElementArrayAPPLE != 0 )	++localInitializedProcCount;

		glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) getExtensionPtr( "glDrawRangeElementArrayAPPLE" );
		if ( glDrawRangeElementArrayAPPLE != 0 )	++localInitializedProcCount;

		glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC) getExtensionPtr( "glElementPointerAPPLE" );
		if ( glElementPointerAPPLE != 0 )	++localInitializedProcCount;

		glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) getExtensionPtr( "glMultiDrawElementArrayAPPLE" );
		if ( glMultiDrawElementArrayAPPLE != 0 )	++localInitializedProcCount;

		glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) getExtensionPtr( "glMultiDrawRangeElementArrayAPPLE" );
		if ( glMultiDrawRangeElementArrayAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_element_array )

	if ( isGL_APPLE_element_array )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_element_array                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_element_array                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_element_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_element_array                            : not detected." );
	}


	isGL_APPLE_fence = isExtensionSupported("GL_APPLE_fence");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_fence ) // || isSEDEnable()
	{
		glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC) getExtensionPtr( "glDeleteFencesAPPLE" );
		if ( glDeleteFencesAPPLE != 0 )	++localInitializedProcCount;

		glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC) getExtensionPtr( "glFinishFenceAPPLE" );
		if ( glFinishFenceAPPLE != 0 )	++localInitializedProcCount;

		glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC) getExtensionPtr( "glFinishObjectAPPLE" );
		if ( glFinishObjectAPPLE != 0 )	++localInitializedProcCount;

		glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC) getExtensionPtr( "glGenFencesAPPLE" );
		if ( glGenFencesAPPLE != 0 )	++localInitializedProcCount;

		glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC) getExtensionPtr( "glIsFenceAPPLE" );
		if ( glIsFenceAPPLE != 0 )	++localInitializedProcCount;

		glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC) getExtensionPtr( "glSetFenceAPPLE" );
		if ( glSetFenceAPPLE != 0 )	++localInitializedProcCount;

		glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC) getExtensionPtr( "glTestFenceAPPLE" );
		if ( glTestFenceAPPLE != 0 )	++localInitializedProcCount;

		glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC) getExtensionPtr( "glTestObjectAPPLE" );
		if ( glTestObjectAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_fence )

	if ( isGL_APPLE_fence )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_fence                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_fence                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_fence") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_fence                                    : not detected." );
	}


	isGL_APPLE_float_pixels = isExtensionSupported("GL_APPLE_float_pixels");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_float_pixels )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_float_pixels                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_float_pixels                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_float_pixels") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_float_pixels                             : not detected." );
	}


	isGL_APPLE_flush_buffer_range = isExtensionSupported("GL_APPLE_flush_buffer_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_flush_buffer_range ) // || isSEDEnable()
	{
		glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC) getExtensionPtr( "glBufferParameteriAPPLE" );
		if ( glBufferParameteriAPPLE != 0 )	++localInitializedProcCount;

		glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) getExtensionPtr( "glFlushMappedBufferRangeAPPLE" );
		if ( glFlushMappedBufferRangeAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_flush_buffer_range )

	if ( isGL_APPLE_flush_buffer_range )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_flush_buffer_range                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_flush_buffer_range                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_flush_buffer_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_flush_buffer_range                       : not detected." );
	}


	isGL_APPLE_object_purgeable = isExtensionSupported("GL_APPLE_object_purgeable");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_object_purgeable ) // || isSEDEnable()
	{
		glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC) getExtensionPtr( "glGetObjectParameterivAPPLE" );
		if ( glGetObjectParameterivAPPLE != 0 )	++localInitializedProcCount;

		glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC) getExtensionPtr( "glObjectPurgeableAPPLE" );
		if ( glObjectPurgeableAPPLE != 0 )	++localInitializedProcCount;

		glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC) getExtensionPtr( "glObjectUnpurgeableAPPLE" );
		if ( glObjectUnpurgeableAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_object_purgeable )

	if ( isGL_APPLE_object_purgeable )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_object_purgeable                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_object_purgeable                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_object_purgeable") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_object_purgeable                         : not detected." );
	}


	isGL_APPLE_rgb_422 = isExtensionSupported("GL_APPLE_rgb_422");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_rgb_422 )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_rgb_422                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_rgb_422                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_rgb_422") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_rgb_422                                  : not detected." );
	}


	isGL_APPLE_row_bytes = isExtensionSupported("GL_APPLE_row_bytes");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_row_bytes )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_row_bytes                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_row_bytes                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_row_bytes") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_row_bytes                                : not detected." );
	}


	isGL_APPLE_specular_vector = isExtensionSupported("GL_APPLE_specular_vector");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_specular_vector )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_specular_vector                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_specular_vector                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_specular_vector") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_specular_vector                          : not detected." );
	}


	isGL_APPLE_texture_range = isExtensionSupported("GL_APPLE_texture_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_texture_range ) // || isSEDEnable()
	{
		glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC) getExtensionPtr( "glGetTexParameterPointervAPPLE" );
		if ( glGetTexParameterPointervAPPLE != 0 )	++localInitializedProcCount;

		glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC) getExtensionPtr( "glTextureRangeAPPLE" );
		if ( glTextureRangeAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_texture_range )

	if ( isGL_APPLE_texture_range )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_texture_range                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_texture_range                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_texture_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_texture_range                            : not detected." );
	}


	isGL_APPLE_transform_hint = isExtensionSupported("GL_APPLE_transform_hint");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_transform_hint )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_transform_hint                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_transform_hint                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_transform_hint") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_transform_hint                           : not detected." );
	}


	isGL_APPLE_vertex_array_object = isExtensionSupported("GL_APPLE_vertex_array_object");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_vertex_array_object ) // || isSEDEnable()
	{
		glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC) getExtensionPtr( "glBindVertexArrayAPPLE" );
		if ( glBindVertexArrayAPPLE != 0 )	++localInitializedProcCount;

		glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC) getExtensionPtr( "glDeleteVertexArraysAPPLE" );
		if ( glDeleteVertexArraysAPPLE != 0 )	++localInitializedProcCount;

		glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC) getExtensionPtr( "glGenVertexArraysAPPLE" );
		if ( glGenVertexArraysAPPLE != 0 )	++localInitializedProcCount;

		glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC) getExtensionPtr( "glIsVertexArrayAPPLE" );
		if ( glIsVertexArrayAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_vertex_array_object )

	if ( isGL_APPLE_vertex_array_object )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_vertex_array_object                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_vertex_array_object                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_vertex_array_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_vertex_array_object                      : not detected." );
	}


	isGL_APPLE_vertex_array_range = isExtensionSupported("GL_APPLE_vertex_array_range");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_vertex_array_range ) // || isSEDEnable()
	{
		glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) getExtensionPtr( "glFlushVertexArrayRangeAPPLE" );
		if ( glFlushVertexArrayRangeAPPLE != 0 )	++localInitializedProcCount;

		glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) getExtensionPtr( "glVertexArrayParameteriAPPLE" );
		if ( glVertexArrayParameteriAPPLE != 0 )	++localInitializedProcCount;

		glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC) getExtensionPtr( "glVertexArrayRangeAPPLE" );
		if ( glVertexArrayRangeAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_vertex_array_range )

	if ( isGL_APPLE_vertex_array_range )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_vertex_array_range                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_vertex_array_range                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_vertex_array_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_vertex_array_range                       : not detected." );
	}


	isGL_APPLE_vertex_program_evaluators = isExtensionSupported("GL_APPLE_vertex_program_evaluators");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_vertex_program_evaluators ) // || isSEDEnable()
	{
		glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC) getExtensionPtr( "glDisableVertexAttribAPPLE" );
		if ( glDisableVertexAttribAPPLE != 0 )	++localInitializedProcCount;

		glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC) getExtensionPtr( "glEnableVertexAttribAPPLE" );
		if ( glEnableVertexAttribAPPLE != 0 )	++localInitializedProcCount;

		glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC) getExtensionPtr( "glIsVertexAttribEnabledAPPLE" );
		if ( glIsVertexAttribEnabledAPPLE != 0 )	++localInitializedProcCount;

		glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC) getExtensionPtr( "glMapVertexAttrib1dAPPLE" );
		if ( glMapVertexAttrib1dAPPLE != 0 )	++localInitializedProcCount;

		glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC) getExtensionPtr( "glMapVertexAttrib1fAPPLE" );
		if ( glMapVertexAttrib1fAPPLE != 0 )	++localInitializedProcCount;

		glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC) getExtensionPtr( "glMapVertexAttrib2dAPPLE" );
		if ( glMapVertexAttrib2dAPPLE != 0 )	++localInitializedProcCount;

		glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC) getExtensionPtr( "glMapVertexAttrib2fAPPLE" );
		if ( glMapVertexAttrib2fAPPLE != 0 )	++localInitializedProcCount;

	} // if ( isGL_APPLE_vertex_program_evaluators )

	if ( isGL_APPLE_vertex_program_evaluators )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_vertex_program_evaluators                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_vertex_program_evaluators                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_vertex_program_evaluators") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_vertex_program_evaluators                : not detected." );
	}


	isGL_APPLE_ycbcr_422 = isExtensionSupported("GL_APPLE_ycbcr_422");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_APPLE_ycbcr_422 )
	{
		std::stringstream strStream;
		strStream << "GL_APPLE_ycbcr_422                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_APPLE_ycbcr_422                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_APPLE_ycbcr_422") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_APPLE_ycbcr_422                                : not detected." );
	}


} // initializeGL_APPLE_ycbcr_422()


void OpenGLExtensionsGen::initializeGL_ARB()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_ARB_ES2_compatibility = isExtensionSupported("GL_ARB_ES2_compatibility");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_ES2_compatibility ) // || isSEDEnable()
	{
		glClearDepthf = (PFNGLCLEARDEPTHFPROC) getExtensionPtr( "glClearDepthf" );
		if ( glClearDepthf != 0 )	++localInitializedProcCount;

		glDepthRangef = (PFNGLDEPTHRANGEFPROC) getExtensionPtr( "glDepthRangef" );
		if ( glDepthRangef != 0 )	++localInitializedProcCount;

		glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC) getExtensionPtr( "glGetShaderPrecisionFormat" );
		if ( glGetShaderPrecisionFormat != 0 )	++localInitializedProcCount;

		glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC) getExtensionPtr( "glReleaseShaderCompiler" );
		if ( glReleaseShaderCompiler != 0 )	++localInitializedProcCount;

		glShaderBinary = (PFNGLSHADERBINARYPROC) getExtensionPtr( "glShaderBinary" );
		if ( glShaderBinary != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_ES2_compatibility )

	if ( isGL_ARB_ES2_compatibility )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_ES2_compatibility                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_ES2_compatibility                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_ES2_compatibility") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_ES2_compatibility                          : not detected." );
	}


	isGL_ARB_ES3_compatibility = isExtensionSupported("GL_ARB_ES3_compatibility");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_ES3_compatibility )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_ES3_compatibility                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_ES3_compatibility                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_ES3_compatibility") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_ES3_compatibility                          : not detected." );
	}


	isGL_ARB_arrays_of_arrays = isExtensionSupported("GL_ARB_arrays_of_arrays");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_arrays_of_arrays )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_arrays_of_arrays                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_arrays_of_arrays                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_arrays_of_arrays") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_arrays_of_arrays                           : not detected." );
	}


	isGL_ARB_base_instance = isExtensionSupported("GL_ARB_base_instance");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_base_instance ) // || isSEDEnable()
	{
		glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC) getExtensionPtr( "glDrawArraysInstancedBaseInstance" );
		if ( glDrawArraysInstancedBaseInstance != 0 )	++localInitializedProcCount;

		glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC) getExtensionPtr( "glDrawElementsInstancedBaseInstance" );
		if ( glDrawElementsInstancedBaseInstance != 0 )	++localInitializedProcCount;

		glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC) getExtensionPtr( "glDrawElementsInstancedBaseVertexBaseInstance" );
		if ( glDrawElementsInstancedBaseVertexBaseInstance != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_base_instance )

	if ( isGL_ARB_base_instance )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_base_instance                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_base_instance                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_base_instance") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_base_instance                              : not detected." );
	}


	isGL_ARB_blend_func_extended = isExtensionSupported("GL_ARB_blend_func_extended");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_blend_func_extended ) // || isSEDEnable()
	{
		glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) getExtensionPtr( "glBindFragDataLocationIndexed" );
		if ( glBindFragDataLocationIndexed != 0 )	++localInitializedProcCount;

		glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC) getExtensionPtr( "glGetFragDataIndex" );
		if ( glGetFragDataIndex != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_blend_func_extended )

	if ( isGL_ARB_blend_func_extended )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_blend_func_extended                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_blend_func_extended                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_blend_func_extended") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_blend_func_extended                        : not detected." );
	}


	isGL_ARB_cl_event = isExtensionSupported("GL_ARB_cl_event");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_cl_event ) // || isSEDEnable()
	{
		glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC) getExtensionPtr( "glCreateSyncFromCLeventARB" );
		if ( glCreateSyncFromCLeventARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_cl_event )

	if ( isGL_ARB_cl_event )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_cl_event                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_cl_event                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_cl_event") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_cl_event                                   : not detected." );
	}


	isGL_ARB_clear_buffer_object = isExtensionSupported("GL_ARB_clear_buffer_object");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_clear_buffer_object ) // || isSEDEnable()
	{
		glClearBufferData = (PFNGLCLEARBUFFERDATAPROC) getExtensionPtr( "glClearBufferData" );
		if ( glClearBufferData != 0 )	++localInitializedProcCount;

		glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC) getExtensionPtr( "glClearBufferSubData" );
		if ( glClearBufferSubData != 0 )	++localInitializedProcCount;

		glClearNamedBufferDataEXT = (PFNGLCLEARNAMEDBUFFERDATAEXTPROC) getExtensionPtr( "glClearNamedBufferDataEXT" );
		if ( glClearNamedBufferDataEXT != 0 )	++localInitializedProcCount;

		glClearNamedBufferSubDataEXT = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC) getExtensionPtr( "glClearNamedBufferSubDataEXT" );
		if ( glClearNamedBufferSubDataEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_clear_buffer_object )

	if ( isGL_ARB_clear_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_clear_buffer_object                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_clear_buffer_object                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_clear_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_clear_buffer_object                        : not detected." );
	}


	isGL_ARB_color_buffer_float = isExtensionSupported("GL_ARB_color_buffer_float");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_color_buffer_float ) // || isSEDEnable()
	{
		glClampColorARB = (PFNGLCLAMPCOLORARBPROC) getExtensionPtr( "glClampColorARB" );
		if ( glClampColorARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_color_buffer_float )

	if ( isGL_ARB_color_buffer_float )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_color_buffer_float                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_color_buffer_float                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_color_buffer_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_color_buffer_float                         : not detected." );
	}


	isGL_ARB_compatibility = isExtensionSupported("GL_ARB_compatibility");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_compatibility )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_compatibility                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_compatibility                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_compatibility") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_compatibility                              : not detected." );
	}


	isGL_ARB_compressed_texture_pixel_storage = isExtensionSupported("GL_ARB_compressed_texture_pixel_storage");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_compressed_texture_pixel_storage )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_compressed_texture_pixel_storage           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_compressed_texture_pixel_storage           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_compressed_texture_pixel_storage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_compressed_texture_pixel_storage           : not detected." );
	}


	isGL_ARB_compute_shader = isExtensionSupported("GL_ARB_compute_shader");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_compute_shader ) // || isSEDEnable()
	{
		glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC) getExtensionPtr( "glDispatchCompute" );
		if ( glDispatchCompute != 0 )	++localInitializedProcCount;

		glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC) getExtensionPtr( "glDispatchComputeIndirect" );
		if ( glDispatchComputeIndirect != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_compute_shader )

	if ( isGL_ARB_compute_shader )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_compute_shader                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_compute_shader                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_compute_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_compute_shader                             : not detected." );
	}


	isGL_ARB_conservative_depth = isExtensionSupported("GL_ARB_conservative_depth");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_conservative_depth )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_conservative_depth                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_conservative_depth                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_conservative_depth") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_conservative_depth                         : not detected." );
	}


	isGL_ARB_copy_buffer = isExtensionSupported("GL_ARB_copy_buffer");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_copy_buffer ) // || isSEDEnable()
	{
		glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC) getExtensionPtr( "glCopyBufferSubData" );
		if ( glCopyBufferSubData != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_copy_buffer )

	if ( isGL_ARB_copy_buffer )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_copy_buffer                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_copy_buffer                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_copy_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_copy_buffer                                : not detected." );
	}


	isGL_ARB_copy_image = isExtensionSupported("GL_ARB_copy_image");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_copy_image ) // || isSEDEnable()
	{
		glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC) getExtensionPtr( "glCopyImageSubData" );
		if ( glCopyImageSubData != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_copy_image )

	if ( isGL_ARB_copy_image )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_copy_image                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_copy_image                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_copy_image") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_copy_image                                 : not detected." );
	}


	isGL_ARB_debug_output = isExtensionSupported("GL_ARB_debug_output");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_debug_output ) // || isSEDEnable()
	{
		glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC) getExtensionPtr( "glDebugMessageCallbackARB" );
		if ( glDebugMessageCallbackARB != 0 )	++localInitializedProcCount;

		glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC) getExtensionPtr( "glDebugMessageControlARB" );
		if ( glDebugMessageControlARB != 0 )	++localInitializedProcCount;

		glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC) getExtensionPtr( "glDebugMessageInsertARB" );
		if ( glDebugMessageInsertARB != 0 )	++localInitializedProcCount;

		glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC) getExtensionPtr( "glGetDebugMessageLogARB" );
		if ( glGetDebugMessageLogARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_debug_output )

	if ( isGL_ARB_debug_output )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_debug_output                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_debug_output                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_debug_output") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_debug_output                               : not detected." );
	}


	isGL_ARB_depth_buffer_float = isExtensionSupported("GL_ARB_depth_buffer_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_depth_buffer_float )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_depth_buffer_float                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_depth_buffer_float                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_depth_buffer_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_depth_buffer_float                         : not detected." );
	}


	isGL_ARB_depth_clamp = isExtensionSupported("GL_ARB_depth_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_depth_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_depth_clamp                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_depth_clamp                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_depth_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_depth_clamp                                : not detected." );
	}


	isGL_ARB_depth_texture = isExtensionSupported("GL_ARB_depth_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_depth_texture )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_depth_texture                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_depth_texture                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_depth_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_depth_texture                              : not detected." );
	}


	isGL_ARB_draw_buffers = isExtensionSupported("GL_ARB_draw_buffers");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_draw_buffers ) // || isSEDEnable()
	{
		glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC) getExtensionPtr( "glDrawBuffersARB" );
		if ( glDrawBuffersARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_draw_buffers )

	if ( isGL_ARB_draw_buffers )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_draw_buffers                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_draw_buffers                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_draw_buffers") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_draw_buffers                               : not detected." );
	}


	isGL_ARB_draw_buffers_blend = isExtensionSupported("GL_ARB_draw_buffers_blend");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_draw_buffers_blend ) // || isSEDEnable()
	{
		glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC) getExtensionPtr( "glBlendEquationSeparateiARB" );
		if ( glBlendEquationSeparateiARB != 0 )	++localInitializedProcCount;

		glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC) getExtensionPtr( "glBlendEquationiARB" );
		if ( glBlendEquationiARB != 0 )	++localInitializedProcCount;

		glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC) getExtensionPtr( "glBlendFuncSeparateiARB" );
		if ( glBlendFuncSeparateiARB != 0 )	++localInitializedProcCount;

		glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC) getExtensionPtr( "glBlendFunciARB" );
		if ( glBlendFunciARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_draw_buffers_blend )

	if ( isGL_ARB_draw_buffers_blend )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_draw_buffers_blend                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_draw_buffers_blend                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_draw_buffers_blend") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_draw_buffers_blend                         : not detected." );
	}


	isGL_ARB_draw_elements_base_vertex = isExtensionSupported("GL_ARB_draw_elements_base_vertex");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_draw_elements_base_vertex ) // || isSEDEnable()
	{
		glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC) getExtensionPtr( "glDrawElementsBaseVertex" );
		if ( glDrawElementsBaseVertex != 0 )	++localInitializedProcCount;

		glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) getExtensionPtr( "glDrawElementsInstancedBaseVertex" );
		if ( glDrawElementsInstancedBaseVertex != 0 )	++localInitializedProcCount;

		glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) getExtensionPtr( "glDrawRangeElementsBaseVertex" );
		if ( glDrawRangeElementsBaseVertex != 0 )	++localInitializedProcCount;

		glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) getExtensionPtr( "glMultiDrawElementsBaseVertex" );
		if ( glMultiDrawElementsBaseVertex != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_draw_elements_base_vertex )

	if ( isGL_ARB_draw_elements_base_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_draw_elements_base_vertex                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_draw_elements_base_vertex                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_draw_elements_base_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_draw_elements_base_vertex                  : not detected." );
	}


	isGL_ARB_draw_indirect = isExtensionSupported("GL_ARB_draw_indirect");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_draw_indirect ) // || isSEDEnable()
	{
		glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC) getExtensionPtr( "glDrawArraysIndirect" );
		if ( glDrawArraysIndirect != 0 )	++localInitializedProcCount;

		glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC) getExtensionPtr( "glDrawElementsIndirect" );
		if ( glDrawElementsIndirect != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_draw_indirect )

	if ( isGL_ARB_draw_indirect )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_draw_indirect                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_draw_indirect                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_draw_indirect") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_draw_indirect                              : not detected." );
	}


	isGL_ARB_draw_instanced = isExtensionSupported("GL_ARB_draw_instanced");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_draw_instanced ) // || isSEDEnable()
	{
		glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC) getExtensionPtr( "glDrawArraysInstancedARB" );
		if ( glDrawArraysInstancedARB != 0 )	++localInitializedProcCount;

		glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC) getExtensionPtr( "glDrawElementsInstancedARB" );
		if ( glDrawElementsInstancedARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_draw_instanced )

	if ( isGL_ARB_draw_instanced )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_draw_instanced                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_draw_instanced                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_draw_instanced") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_draw_instanced                             : not detected." );
	}


	isGL_ARB_explicit_attrib_location = isExtensionSupported("GL_ARB_explicit_attrib_location");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_explicit_attrib_location )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_explicit_attrib_location                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_explicit_attrib_location                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_explicit_attrib_location") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_explicit_attrib_location                   : not detected." );
	}


	isGL_ARB_explicit_uniform_location = isExtensionSupported("GL_ARB_explicit_uniform_location");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_explicit_uniform_location )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_explicit_uniform_location                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_explicit_uniform_location                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_explicit_uniform_location") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_explicit_uniform_location                  : not detected." );
	}


	isGL_ARB_fragment_coord_conventions = isExtensionSupported("GL_ARB_fragment_coord_conventions");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_fragment_coord_conventions )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_fragment_coord_conventions                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_fragment_coord_conventions                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_fragment_coord_conventions") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_fragment_coord_conventions                 : not detected." );
	}


	isGL_ARB_fragment_layer_viewport = isExtensionSupported("GL_ARB_fragment_layer_viewport");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_fragment_layer_viewport )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_fragment_layer_viewport                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_fragment_layer_viewport                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_fragment_layer_viewport") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_fragment_layer_viewport                    : not detected." );
	}


	isGL_ARB_fragment_program = isExtensionSupported("GL_ARB_fragment_program");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_fragment_program )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_fragment_program                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_fragment_program                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_fragment_program") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_fragment_program                           : not detected." );
	}


	isGL_ARB_fragment_program_shadow = isExtensionSupported("GL_ARB_fragment_program_shadow");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_fragment_program_shadow )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_fragment_program_shadow                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_fragment_program_shadow                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_fragment_program_shadow") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_fragment_program_shadow                    : not detected." );
	}


	isGL_ARB_fragment_shader = isExtensionSupported("GL_ARB_fragment_shader");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_fragment_shader )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_fragment_shader                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_fragment_shader                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_fragment_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_fragment_shader                            : not detected." );
	}


	isGL_ARB_framebuffer_no_attachments = isExtensionSupported("GL_ARB_framebuffer_no_attachments");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_framebuffer_no_attachments ) // || isSEDEnable()
	{
		glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC) getExtensionPtr( "glFramebufferParameteri" );
		if ( glFramebufferParameteri != 0 )	++localInitializedProcCount;

		glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC) getExtensionPtr( "glGetFramebufferParameteriv" );
		if ( glGetFramebufferParameteriv != 0 )	++localInitializedProcCount;

		glGetNamedFramebufferParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC) getExtensionPtr( "glGetNamedFramebufferParameterivEXT" );
		if ( glGetNamedFramebufferParameterivEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferParameteriEXT = (PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC) getExtensionPtr( "glNamedFramebufferParameteriEXT" );
		if ( glNamedFramebufferParameteriEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_framebuffer_no_attachments )

	if ( isGL_ARB_framebuffer_no_attachments )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_framebuffer_no_attachments                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_framebuffer_no_attachments                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_framebuffer_no_attachments") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_framebuffer_no_attachments                 : not detected." );
	}


	isGL_ARB_framebuffer_object = isExtensionSupported("GL_ARB_framebuffer_object");

	localSupportedProcCount		= 20;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_framebuffer_object ) // || isSEDEnable()
	{
		glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) getExtensionPtr( "glBindFramebuffer" );
		if ( glBindFramebuffer != 0 )	++localInitializedProcCount;

		glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) getExtensionPtr( "glBindRenderbuffer" );
		if ( glBindRenderbuffer != 0 )	++localInitializedProcCount;

		glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) getExtensionPtr( "glBlitFramebuffer" );
		if ( glBlitFramebuffer != 0 )	++localInitializedProcCount;

		glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) getExtensionPtr( "glCheckFramebufferStatus" );
		if ( glCheckFramebufferStatus != 0 )	++localInitializedProcCount;

		glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) getExtensionPtr( "glDeleteFramebuffers" );
		if ( glDeleteFramebuffers != 0 )	++localInitializedProcCount;

		glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) getExtensionPtr( "glDeleteRenderbuffers" );
		if ( glDeleteRenderbuffers != 0 )	++localInitializedProcCount;

		glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) getExtensionPtr( "glFramebufferRenderbuffer" );
		if ( glFramebufferRenderbuffer != 0 )	++localInitializedProcCount;

		glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) getExtensionPtr( "glFramebufferTexture1D" );
		if ( glFramebufferTexture1D != 0 )	++localInitializedProcCount;

		glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) getExtensionPtr( "glFramebufferTexture2D" );
		if ( glFramebufferTexture2D != 0 )	++localInitializedProcCount;

		glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) getExtensionPtr( "glFramebufferTexture3D" );
		if ( glFramebufferTexture3D != 0 )	++localInitializedProcCount;

		glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) getExtensionPtr( "glFramebufferTextureLayer" );
		if ( glFramebufferTextureLayer != 0 )	++localInitializedProcCount;

		glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) getExtensionPtr( "glGenFramebuffers" );
		if ( glGenFramebuffers != 0 )	++localInitializedProcCount;

		glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) getExtensionPtr( "glGenRenderbuffers" );
		if ( glGenRenderbuffers != 0 )	++localInitializedProcCount;

		glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) getExtensionPtr( "glGenerateMipmap" );
		if ( glGenerateMipmap != 0 )	++localInitializedProcCount;

		glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) getExtensionPtr( "glGetFramebufferAttachmentParameteriv" );
		if ( glGetFramebufferAttachmentParameteriv != 0 )	++localInitializedProcCount;

		glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) getExtensionPtr( "glGetRenderbufferParameteriv" );
		if ( glGetRenderbufferParameteriv != 0 )	++localInitializedProcCount;

		glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) getExtensionPtr( "glIsFramebuffer" );
		if ( glIsFramebuffer != 0 )	++localInitializedProcCount;

		glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) getExtensionPtr( "glIsRenderbuffer" );
		if ( glIsRenderbuffer != 0 )	++localInitializedProcCount;

		glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) getExtensionPtr( "glRenderbufferStorage" );
		if ( glRenderbufferStorage != 0 )	++localInitializedProcCount;

		glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) getExtensionPtr( "glRenderbufferStorageMultisample" );
		if ( glRenderbufferStorageMultisample != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_framebuffer_object )

	if ( isGL_ARB_framebuffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_framebuffer_object                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_framebuffer_object                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_framebuffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_framebuffer_object                         : not detected." );
	}


	isGL_ARB_framebuffer_sRGB = isExtensionSupported("GL_ARB_framebuffer_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_framebuffer_sRGB )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_framebuffer_sRGB                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_framebuffer_sRGB                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_framebuffer_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_framebuffer_sRGB                           : not detected." );
	}


	isGL_ARB_geometry_shader4 = isExtensionSupported("GL_ARB_geometry_shader4");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_geometry_shader4 ) // || isSEDEnable()
	{
		glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC) getExtensionPtr( "glFramebufferTextureARB" );
		if ( glFramebufferTextureARB != 0 )	++localInitializedProcCount;

		glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) getExtensionPtr( "glFramebufferTextureFaceARB" );
		if ( glFramebufferTextureFaceARB != 0 )	++localInitializedProcCount;

		glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) getExtensionPtr( "glFramebufferTextureLayerARB" );
		if ( glFramebufferTextureLayerARB != 0 )	++localInitializedProcCount;

		glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC) getExtensionPtr( "glProgramParameteriARB" );
		if ( glProgramParameteriARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_geometry_shader4 )

	if ( isGL_ARB_geometry_shader4 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_geometry_shader4                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_geometry_shader4                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_geometry_shader4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_geometry_shader4                           : not detected." );
	}


	isGL_ARB_get_program_binary = isExtensionSupported("GL_ARB_get_program_binary");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_get_program_binary ) // || isSEDEnable()
	{
		glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC) getExtensionPtr( "glGetProgramBinary" );
		if ( glGetProgramBinary != 0 )	++localInitializedProcCount;

		glProgramBinary = (PFNGLPROGRAMBINARYPROC) getExtensionPtr( "glProgramBinary" );
		if ( glProgramBinary != 0 )	++localInitializedProcCount;

		glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC) getExtensionPtr( "glProgramParameteri" );
		if ( glProgramParameteri != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_get_program_binary )

	if ( isGL_ARB_get_program_binary )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_get_program_binary                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_get_program_binary                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_get_program_binary") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_get_program_binary                         : not detected." );
	}


	isGL_ARB_gpu_shader5 = isExtensionSupported("GL_ARB_gpu_shader5");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_gpu_shader5 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_gpu_shader5                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_gpu_shader5                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_gpu_shader5") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_gpu_shader5                                : not detected." );
	}


	isGL_ARB_gpu_shader_fp64 = isExtensionSupported("GL_ARB_gpu_shader_fp64");

	localSupportedProcCount		= 18;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_gpu_shader_fp64 ) // || isSEDEnable()
	{
		glGetUniformdv = (PFNGLGETUNIFORMDVPROC) getExtensionPtr( "glGetUniformdv" );
		if ( glGetUniformdv != 0 )	++localInitializedProcCount;

		glUniform1d = (PFNGLUNIFORM1DPROC) getExtensionPtr( "glUniform1d" );
		if ( glUniform1d != 0 )	++localInitializedProcCount;

		glUniform1dv = (PFNGLUNIFORM1DVPROC) getExtensionPtr( "glUniform1dv" );
		if ( glUniform1dv != 0 )	++localInitializedProcCount;

		glUniform2d = (PFNGLUNIFORM2DPROC) getExtensionPtr( "glUniform2d" );
		if ( glUniform2d != 0 )	++localInitializedProcCount;

		glUniform2dv = (PFNGLUNIFORM2DVPROC) getExtensionPtr( "glUniform2dv" );
		if ( glUniform2dv != 0 )	++localInitializedProcCount;

		glUniform3d = (PFNGLUNIFORM3DPROC) getExtensionPtr( "glUniform3d" );
		if ( glUniform3d != 0 )	++localInitializedProcCount;

		glUniform3dv = (PFNGLUNIFORM3DVPROC) getExtensionPtr( "glUniform3dv" );
		if ( glUniform3dv != 0 )	++localInitializedProcCount;

		glUniform4d = (PFNGLUNIFORM4DPROC) getExtensionPtr( "glUniform4d" );
		if ( glUniform4d != 0 )	++localInitializedProcCount;

		glUniform4dv = (PFNGLUNIFORM4DVPROC) getExtensionPtr( "glUniform4dv" );
		if ( glUniform4dv != 0 )	++localInitializedProcCount;

		glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC) getExtensionPtr( "glUniformMatrix2dv" );
		if ( glUniformMatrix2dv != 0 )	++localInitializedProcCount;

		glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC) getExtensionPtr( "glUniformMatrix2x3dv" );
		if ( glUniformMatrix2x3dv != 0 )	++localInitializedProcCount;

		glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC) getExtensionPtr( "glUniformMatrix2x4dv" );
		if ( glUniformMatrix2x4dv != 0 )	++localInitializedProcCount;

		glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC) getExtensionPtr( "glUniformMatrix3dv" );
		if ( glUniformMatrix3dv != 0 )	++localInitializedProcCount;

		glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC) getExtensionPtr( "glUniformMatrix3x2dv" );
		if ( glUniformMatrix3x2dv != 0 )	++localInitializedProcCount;

		glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC) getExtensionPtr( "glUniformMatrix3x4dv" );
		if ( glUniformMatrix3x4dv != 0 )	++localInitializedProcCount;

		glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC) getExtensionPtr( "glUniformMatrix4dv" );
		if ( glUniformMatrix4dv != 0 )	++localInitializedProcCount;

		glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC) getExtensionPtr( "glUniformMatrix4x2dv" );
		if ( glUniformMatrix4x2dv != 0 )	++localInitializedProcCount;

		glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC) getExtensionPtr( "glUniformMatrix4x3dv" );
		if ( glUniformMatrix4x3dv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_gpu_shader_fp64 )

	if ( isGL_ARB_gpu_shader_fp64 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_gpu_shader_fp64                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_gpu_shader_fp64                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_gpu_shader_fp64") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_gpu_shader_fp64                            : not detected." );
	}


	isGL_ARB_half_float_pixel = isExtensionSupported("GL_ARB_half_float_pixel");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_half_float_pixel )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_half_float_pixel                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_half_float_pixel                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_half_float_pixel") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_half_float_pixel                           : not detected." );
	}


	isGL_ARB_half_float_vertex = isExtensionSupported("GL_ARB_half_float_vertex");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_half_float_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_half_float_vertex                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_half_float_vertex                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_half_float_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_half_float_vertex                          : not detected." );
	}


	isGL_ARB_imaging = isExtensionSupported("GL_ARB_imaging");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_imaging )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_imaging                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_imaging                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_imaging") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_imaging                                    : not detected." );
	}


	isGL_ARB_instanced_arrays = isExtensionSupported("GL_ARB_instanced_arrays");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_instanced_arrays ) // || isSEDEnable()
	{
		glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC) getExtensionPtr( "glVertexAttribDivisorARB" );
		if ( glVertexAttribDivisorARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_instanced_arrays )

	if ( isGL_ARB_instanced_arrays )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_instanced_arrays                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_instanced_arrays                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_instanced_arrays") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_instanced_arrays                           : not detected." );
	}


	isGL_ARB_internalformat_query = isExtensionSupported("GL_ARB_internalformat_query");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_internalformat_query ) // || isSEDEnable()
	{
		glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC) getExtensionPtr( "glGetInternalformativ" );
		if ( glGetInternalformativ != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_internalformat_query )

	if ( isGL_ARB_internalformat_query )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_internalformat_query                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_internalformat_query                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_internalformat_query") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_internalformat_query                       : not detected." );
	}


	isGL_ARB_internalformat_query2 = isExtensionSupported("GL_ARB_internalformat_query2");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_internalformat_query2 ) // || isSEDEnable()
	{
		glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC) getExtensionPtr( "glGetInternalformati64v" );
		if ( glGetInternalformati64v != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_internalformat_query2 )

	if ( isGL_ARB_internalformat_query2 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_internalformat_query2                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_internalformat_query2                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_internalformat_query2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_internalformat_query2                      : not detected." );
	}


	isGL_ARB_invalidate_subdata = isExtensionSupported("GL_ARB_invalidate_subdata");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_invalidate_subdata ) // || isSEDEnable()
	{
		glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC) getExtensionPtr( "glInvalidateBufferData" );
		if ( glInvalidateBufferData != 0 )	++localInitializedProcCount;

		glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC) getExtensionPtr( "glInvalidateBufferSubData" );
		if ( glInvalidateBufferSubData != 0 )	++localInitializedProcCount;

		glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC) getExtensionPtr( "glInvalidateFramebuffer" );
		if ( glInvalidateFramebuffer != 0 )	++localInitializedProcCount;

		glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC) getExtensionPtr( "glInvalidateSubFramebuffer" );
		if ( glInvalidateSubFramebuffer != 0 )	++localInitializedProcCount;

		glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC) getExtensionPtr( "glInvalidateTexImage" );
		if ( glInvalidateTexImage != 0 )	++localInitializedProcCount;

		glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC) getExtensionPtr( "glInvalidateTexSubImage" );
		if ( glInvalidateTexSubImage != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_invalidate_subdata )

	if ( isGL_ARB_invalidate_subdata )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_invalidate_subdata                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_invalidate_subdata                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_invalidate_subdata") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_invalidate_subdata                         : not detected." );
	}


	isGL_ARB_map_buffer_alignment = isExtensionSupported("GL_ARB_map_buffer_alignment");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_map_buffer_alignment )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_map_buffer_alignment                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_map_buffer_alignment                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_map_buffer_alignment") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_map_buffer_alignment                       : not detected." );
	}


	isGL_ARB_map_buffer_range = isExtensionSupported("GL_ARB_map_buffer_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_map_buffer_range ) // || isSEDEnable()
	{
		glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC) getExtensionPtr( "glFlushMappedBufferRange" );
		if ( glFlushMappedBufferRange != 0 )	++localInitializedProcCount;

		glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC) getExtensionPtr( "glMapBufferRange" );
		if ( glMapBufferRange != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_map_buffer_range )

	if ( isGL_ARB_map_buffer_range )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_map_buffer_range                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_map_buffer_range                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_map_buffer_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_map_buffer_range                           : not detected." );
	}


	isGL_ARB_matrix_palette = isExtensionSupported("GL_ARB_matrix_palette");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_matrix_palette ) // || isSEDEnable()
	{
		glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC) getExtensionPtr( "glCurrentPaletteMatrixARB" );
		if ( glCurrentPaletteMatrixARB != 0 )	++localInitializedProcCount;

		glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC) getExtensionPtr( "glMatrixIndexPointerARB" );
		if ( glMatrixIndexPointerARB != 0 )	++localInitializedProcCount;

		glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC) getExtensionPtr( "glMatrixIndexubvARB" );
		if ( glMatrixIndexubvARB != 0 )	++localInitializedProcCount;

		glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC) getExtensionPtr( "glMatrixIndexuivARB" );
		if ( glMatrixIndexuivARB != 0 )	++localInitializedProcCount;

		glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC) getExtensionPtr( "glMatrixIndexusvARB" );
		if ( glMatrixIndexusvARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_matrix_palette )

	if ( isGL_ARB_matrix_palette )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_matrix_palette                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_matrix_palette                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_matrix_palette") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_matrix_palette                             : not detected." );
	}


	isGL_ARB_multi_draw_indirect = isExtensionSupported("GL_ARB_multi_draw_indirect");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_multi_draw_indirect ) // || isSEDEnable()
	{
		glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC) getExtensionPtr( "glMultiDrawArraysIndirect" );
		if ( glMultiDrawArraysIndirect != 0 )	++localInitializedProcCount;

		glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC) getExtensionPtr( "glMultiDrawElementsIndirect" );
		if ( glMultiDrawElementsIndirect != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_multi_draw_indirect )

	if ( isGL_ARB_multi_draw_indirect )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_multi_draw_indirect                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_multi_draw_indirect                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_multi_draw_indirect") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_multi_draw_indirect                        : not detected." );
	}


	isGL_ARB_multisample = isExtensionSupported("GL_ARB_multisample");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_multisample ) // || isSEDEnable()
	{
		glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC) getExtensionPtr( "glSampleCoverageARB" );
		if ( glSampleCoverageARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_multisample )

	if ( isGL_ARB_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_multisample                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_multisample                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_multisample                                : not detected." );
	}


	isGL_ARB_multitexture = isExtensionSupported("GL_ARB_multitexture");

	localSupportedProcCount		= 34;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_multitexture ) // || isSEDEnable()
	{
		glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) getExtensionPtr( "glActiveTextureARB" );
		if ( glActiveTextureARB != 0 )	++localInitializedProcCount;

		glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) getExtensionPtr( "glClientActiveTextureARB" );
		if ( glClientActiveTextureARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) getExtensionPtr( "glMultiTexCoord1dARB" );
		if ( glMultiTexCoord1dARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) getExtensionPtr( "glMultiTexCoord1dvARB" );
		if ( glMultiTexCoord1dvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) getExtensionPtr( "glMultiTexCoord1fARB" );
		if ( glMultiTexCoord1fARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) getExtensionPtr( "glMultiTexCoord1fvARB" );
		if ( glMultiTexCoord1fvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) getExtensionPtr( "glMultiTexCoord1iARB" );
		if ( glMultiTexCoord1iARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) getExtensionPtr( "glMultiTexCoord1ivARB" );
		if ( glMultiTexCoord1ivARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) getExtensionPtr( "glMultiTexCoord1sARB" );
		if ( glMultiTexCoord1sARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) getExtensionPtr( "glMultiTexCoord1svARB" );
		if ( glMultiTexCoord1svARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) getExtensionPtr( "glMultiTexCoord2dARB" );
		if ( glMultiTexCoord2dARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) getExtensionPtr( "glMultiTexCoord2dvARB" );
		if ( glMultiTexCoord2dvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) getExtensionPtr( "glMultiTexCoord2fARB" );
		if ( glMultiTexCoord2fARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) getExtensionPtr( "glMultiTexCoord2fvARB" );
		if ( glMultiTexCoord2fvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC) getExtensionPtr( "glMultiTexCoord2iARB" );
		if ( glMultiTexCoord2iARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC) getExtensionPtr( "glMultiTexCoord2ivARB" );
		if ( glMultiTexCoord2ivARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC) getExtensionPtr( "glMultiTexCoord2sARB" );
		if ( glMultiTexCoord2sARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC) getExtensionPtr( "glMultiTexCoord2svARB" );
		if ( glMultiTexCoord2svARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC) getExtensionPtr( "glMultiTexCoord3dARB" );
		if ( glMultiTexCoord3dARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC) getExtensionPtr( "glMultiTexCoord3dvARB" );
		if ( glMultiTexCoord3dvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC) getExtensionPtr( "glMultiTexCoord3fARB" );
		if ( glMultiTexCoord3fARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC) getExtensionPtr( "glMultiTexCoord3fvARB" );
		if ( glMultiTexCoord3fvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC) getExtensionPtr( "glMultiTexCoord3iARB" );
		if ( glMultiTexCoord3iARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC) getExtensionPtr( "glMultiTexCoord3ivARB" );
		if ( glMultiTexCoord3ivARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC) getExtensionPtr( "glMultiTexCoord3sARB" );
		if ( glMultiTexCoord3sARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC) getExtensionPtr( "glMultiTexCoord3svARB" );
		if ( glMultiTexCoord3svARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC) getExtensionPtr( "glMultiTexCoord4dARB" );
		if ( glMultiTexCoord4dARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC) getExtensionPtr( "glMultiTexCoord4dvARB" );
		if ( glMultiTexCoord4dvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC) getExtensionPtr( "glMultiTexCoord4fARB" );
		if ( glMultiTexCoord4fARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC) getExtensionPtr( "glMultiTexCoord4fvARB" );
		if ( glMultiTexCoord4fvARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC) getExtensionPtr( "glMultiTexCoord4iARB" );
		if ( glMultiTexCoord4iARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC) getExtensionPtr( "glMultiTexCoord4ivARB" );
		if ( glMultiTexCoord4ivARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC) getExtensionPtr( "glMultiTexCoord4sARB" );
		if ( glMultiTexCoord4sARB != 0 )	++localInitializedProcCount;

		glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC) getExtensionPtr( "glMultiTexCoord4svARB" );
		if ( glMultiTexCoord4svARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_multitexture )

	if ( isGL_ARB_multitexture )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_multitexture                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_multitexture                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_multitexture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_multitexture                               : not detected." );
	}


	isGL_ARB_occlusion_query = isExtensionSupported("GL_ARB_occlusion_query");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_occlusion_query ) // || isSEDEnable()
	{
		glBeginQueryARB = (PFNGLBEGINQUERYARBPROC) getExtensionPtr( "glBeginQueryARB" );
		if ( glBeginQueryARB != 0 )	++localInitializedProcCount;

		glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC) getExtensionPtr( "glDeleteQueriesARB" );
		if ( glDeleteQueriesARB != 0 )	++localInitializedProcCount;

		glEndQueryARB = (PFNGLENDQUERYARBPROC) getExtensionPtr( "glEndQueryARB" );
		if ( glEndQueryARB != 0 )	++localInitializedProcCount;

		glGenQueriesARB = (PFNGLGENQUERIESARBPROC) getExtensionPtr( "glGenQueriesARB" );
		if ( glGenQueriesARB != 0 )	++localInitializedProcCount;

		glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC) getExtensionPtr( "glGetQueryObjectivARB" );
		if ( glGetQueryObjectivARB != 0 )	++localInitializedProcCount;

		glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC) getExtensionPtr( "glGetQueryObjectuivARB" );
		if ( glGetQueryObjectuivARB != 0 )	++localInitializedProcCount;

		glGetQueryivARB = (PFNGLGETQUERYIVARBPROC) getExtensionPtr( "glGetQueryivARB" );
		if ( glGetQueryivARB != 0 )	++localInitializedProcCount;

		glIsQueryARB = (PFNGLISQUERYARBPROC) getExtensionPtr( "glIsQueryARB" );
		if ( glIsQueryARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_occlusion_query )

	if ( isGL_ARB_occlusion_query )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_occlusion_query                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_occlusion_query                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_occlusion_query") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_occlusion_query                            : not detected." );
	}


	isGL_ARB_occlusion_query2 = isExtensionSupported("GL_ARB_occlusion_query2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_occlusion_query2 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_occlusion_query2                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_occlusion_query2                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_occlusion_query2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_occlusion_query2                           : not detected." );
	}


	isGL_ARB_pixel_buffer_object = isExtensionSupported("GL_ARB_pixel_buffer_object");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_pixel_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_pixel_buffer_object                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_pixel_buffer_object                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_pixel_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_pixel_buffer_object                        : not detected." );
	}


	isGL_ARB_point_parameters = isExtensionSupported("GL_ARB_point_parameters");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_point_parameters ) // || isSEDEnable()
	{
		glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC) getExtensionPtr( "glPointParameterfARB" );
		if ( glPointParameterfARB != 0 )	++localInitializedProcCount;

		glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC) getExtensionPtr( "glPointParameterfvARB" );
		if ( glPointParameterfvARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_point_parameters )

	if ( isGL_ARB_point_parameters )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_point_parameters                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_point_parameters                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_point_parameters") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_point_parameters                           : not detected." );
	}


	isGL_ARB_point_sprite = isExtensionSupported("GL_ARB_point_sprite");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_point_sprite )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_point_sprite                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_point_sprite                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_point_sprite") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_point_sprite                               : not detected." );
	}


	isGL_ARB_program_interface_query = isExtensionSupported("GL_ARB_program_interface_query");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_program_interface_query ) // || isSEDEnable()
	{
		glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC) getExtensionPtr( "glGetProgramInterfaceiv" );
		if ( glGetProgramInterfaceiv != 0 )	++localInitializedProcCount;

		glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC) getExtensionPtr( "glGetProgramResourceIndex" );
		if ( glGetProgramResourceIndex != 0 )	++localInitializedProcCount;

		glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC) getExtensionPtr( "glGetProgramResourceLocation" );
		if ( glGetProgramResourceLocation != 0 )	++localInitializedProcCount;

		glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC) getExtensionPtr( "glGetProgramResourceLocationIndex" );
		if ( glGetProgramResourceLocationIndex != 0 )	++localInitializedProcCount;

		glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC) getExtensionPtr( "glGetProgramResourceName" );
		if ( glGetProgramResourceName != 0 )	++localInitializedProcCount;

		glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC) getExtensionPtr( "glGetProgramResourceiv" );
		if ( glGetProgramResourceiv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_program_interface_query )

	if ( isGL_ARB_program_interface_query )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_program_interface_query                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_program_interface_query                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_program_interface_query") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_program_interface_query                    : not detected." );
	}


	isGL_ARB_provoking_vertex = isExtensionSupported("GL_ARB_provoking_vertex");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_provoking_vertex ) // || isSEDEnable()
	{
		glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC) getExtensionPtr( "glProvokingVertex" );
		if ( glProvokingVertex != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_provoking_vertex )

	if ( isGL_ARB_provoking_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_provoking_vertex                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_provoking_vertex                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_provoking_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_provoking_vertex                           : not detected." );
	}


	isGL_ARB_robust_buffer_access_behavior = isExtensionSupported("GL_ARB_robust_buffer_access_behavior");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_robust_buffer_access_behavior )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_robust_buffer_access_behavior              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_robust_buffer_access_behavior              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_robust_buffer_access_behavior") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_robust_buffer_access_behavior              : not detected." );
	}


	isGL_ARB_robustness = isExtensionSupported("GL_ARB_robustness");

	localSupportedProcCount		= 20;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_robustness ) // || isSEDEnable()
	{
		glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC) getExtensionPtr( "glGetGraphicsResetStatusARB" );
		if ( glGetGraphicsResetStatusARB != 0 )	++localInitializedProcCount;

		glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC) getExtensionPtr( "glGetnColorTableARB" );
		if ( glGetnColorTableARB != 0 )	++localInitializedProcCount;

		glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC) getExtensionPtr( "glGetnCompressedTexImageARB" );
		if ( glGetnCompressedTexImageARB != 0 )	++localInitializedProcCount;

		glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC) getExtensionPtr( "glGetnConvolutionFilterARB" );
		if ( glGetnConvolutionFilterARB != 0 )	++localInitializedProcCount;

		glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC) getExtensionPtr( "glGetnHistogramARB" );
		if ( glGetnHistogramARB != 0 )	++localInitializedProcCount;

		glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC) getExtensionPtr( "glGetnMapdvARB" );
		if ( glGetnMapdvARB != 0 )	++localInitializedProcCount;

		glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC) getExtensionPtr( "glGetnMapfvARB" );
		if ( glGetnMapfvARB != 0 )	++localInitializedProcCount;

		glGetnMapivARB = (PFNGLGETNMAPIVARBPROC) getExtensionPtr( "glGetnMapivARB" );
		if ( glGetnMapivARB != 0 )	++localInitializedProcCount;

		glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC) getExtensionPtr( "glGetnMinmaxARB" );
		if ( glGetnMinmaxARB != 0 )	++localInitializedProcCount;

		glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC) getExtensionPtr( "glGetnPixelMapfvARB" );
		if ( glGetnPixelMapfvARB != 0 )	++localInitializedProcCount;

		glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC) getExtensionPtr( "glGetnPixelMapuivARB" );
		if ( glGetnPixelMapuivARB != 0 )	++localInitializedProcCount;

		glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC) getExtensionPtr( "glGetnPixelMapusvARB" );
		if ( glGetnPixelMapusvARB != 0 )	++localInitializedProcCount;

		glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC) getExtensionPtr( "glGetnPolygonStippleARB" );
		if ( glGetnPolygonStippleARB != 0 )	++localInitializedProcCount;

		glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC) getExtensionPtr( "glGetnSeparableFilterARB" );
		if ( glGetnSeparableFilterARB != 0 )	++localInitializedProcCount;

		glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC) getExtensionPtr( "glGetnTexImageARB" );
		if ( glGetnTexImageARB != 0 )	++localInitializedProcCount;

		glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC) getExtensionPtr( "glGetnUniformdvARB" );
		if ( glGetnUniformdvARB != 0 )	++localInitializedProcCount;

		glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC) getExtensionPtr( "glGetnUniformfvARB" );
		if ( glGetnUniformfvARB != 0 )	++localInitializedProcCount;

		glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC) getExtensionPtr( "glGetnUniformivARB" );
		if ( glGetnUniformivARB != 0 )	++localInitializedProcCount;

		glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC) getExtensionPtr( "glGetnUniformuivARB" );
		if ( glGetnUniformuivARB != 0 )	++localInitializedProcCount;

		glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC) getExtensionPtr( "glReadnPixelsARB" );
		if ( glReadnPixelsARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_robustness )

	if ( isGL_ARB_robustness )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_robustness                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_robustness                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_robustness") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_robustness                                 : not detected." );
	}


	isGL_ARB_robustness_isolation = isExtensionSupported("GL_ARB_robustness_isolation");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_robustness_isolation )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_robustness_isolation                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_robustness_isolation                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_robustness_isolation") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_robustness_isolation                       : not detected." );
	}


	isGL_ARB_sample_shading = isExtensionSupported("GL_ARB_sample_shading");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_sample_shading ) // || isSEDEnable()
	{
		glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC) getExtensionPtr( "glMinSampleShadingARB" );
		if ( glMinSampleShadingARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_sample_shading )

	if ( isGL_ARB_sample_shading )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_sample_shading                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_sample_shading                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_sample_shading") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_sample_shading                             : not detected." );
	}


	isGL_ARB_sampler_objects = isExtensionSupported("GL_ARB_sampler_objects");

	localSupportedProcCount		= 14;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_sampler_objects ) // || isSEDEnable()
	{
		glBindSampler = (PFNGLBINDSAMPLERPROC) getExtensionPtr( "glBindSampler" );
		if ( glBindSampler != 0 )	++localInitializedProcCount;

		glDeleteSamplers = (PFNGLDELETESAMPLERSPROC) getExtensionPtr( "glDeleteSamplers" );
		if ( glDeleteSamplers != 0 )	++localInitializedProcCount;

		glGenSamplers = (PFNGLGENSAMPLERSPROC) getExtensionPtr( "glGenSamplers" );
		if ( glGenSamplers != 0 )	++localInitializedProcCount;

		glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC) getExtensionPtr( "glGetSamplerParameterIiv" );
		if ( glGetSamplerParameterIiv != 0 )	++localInitializedProcCount;

		glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC) getExtensionPtr( "glGetSamplerParameterIuiv" );
		if ( glGetSamplerParameterIuiv != 0 )	++localInitializedProcCount;

		glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC) getExtensionPtr( "glGetSamplerParameterfv" );
		if ( glGetSamplerParameterfv != 0 )	++localInitializedProcCount;

		glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC) getExtensionPtr( "glGetSamplerParameteriv" );
		if ( glGetSamplerParameteriv != 0 )	++localInitializedProcCount;

		glIsSampler = (PFNGLISSAMPLERPROC) getExtensionPtr( "glIsSampler" );
		if ( glIsSampler != 0 )	++localInitializedProcCount;

		glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC) getExtensionPtr( "glSamplerParameterIiv" );
		if ( glSamplerParameterIiv != 0 )	++localInitializedProcCount;

		glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC) getExtensionPtr( "glSamplerParameterIuiv" );
		if ( glSamplerParameterIuiv != 0 )	++localInitializedProcCount;

		glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC) getExtensionPtr( "glSamplerParameterf" );
		if ( glSamplerParameterf != 0 )	++localInitializedProcCount;

		glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC) getExtensionPtr( "glSamplerParameterfv" );
		if ( glSamplerParameterfv != 0 )	++localInitializedProcCount;

		glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC) getExtensionPtr( "glSamplerParameteri" );
		if ( glSamplerParameteri != 0 )	++localInitializedProcCount;

		glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC) getExtensionPtr( "glSamplerParameteriv" );
		if ( glSamplerParameteriv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_sampler_objects )

	if ( isGL_ARB_sampler_objects )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_sampler_objects                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_sampler_objects                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_sampler_objects") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_sampler_objects                            : not detected." );
	}


	isGL_ARB_seamless_cube_map = isExtensionSupported("GL_ARB_seamless_cube_map");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_seamless_cube_map )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_seamless_cube_map                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_seamless_cube_map                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_seamless_cube_map") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_seamless_cube_map                          : not detected." );
	}


	isGL_ARB_separate_shader_objects = isExtensionSupported("GL_ARB_separate_shader_objects");

	localSupportedProcCount		= 60;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_separate_shader_objects ) // || isSEDEnable()
	{
		glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC) getExtensionPtr( "glActiveShaderProgram" );
		if ( glActiveShaderProgram != 0 )	++localInitializedProcCount;

		glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC) getExtensionPtr( "glBindProgramPipeline" );
		if ( glBindProgramPipeline != 0 )	++localInitializedProcCount;

		glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC) getExtensionPtr( "glCreateShaderProgramv" );
		if ( glCreateShaderProgramv != 0 )	++localInitializedProcCount;

		glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC) getExtensionPtr( "glDeleteProgramPipelines" );
		if ( glDeleteProgramPipelines != 0 )	++localInitializedProcCount;

		glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC) getExtensionPtr( "glGenProgramPipelines" );
		if ( glGenProgramPipelines != 0 )	++localInitializedProcCount;

		glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC) getExtensionPtr( "glGetProgramPipelineInfoLog" );
		if ( glGetProgramPipelineInfoLog != 0 )	++localInitializedProcCount;

		glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC) getExtensionPtr( "glGetProgramPipelineiv" );
		if ( glGetProgramPipelineiv != 0 )	++localInitializedProcCount;

		glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC) getExtensionPtr( "glIsProgramPipeline" );
		if ( glIsProgramPipeline != 0 )	++localInitializedProcCount;

		glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC) getExtensionPtr( "glProgramUniform1d" );
		if ( glProgramUniform1d != 0 )	++localInitializedProcCount;

		glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC) getExtensionPtr( "glProgramUniform1dv" );
		if ( glProgramUniform1dv != 0 )	++localInitializedProcCount;

		glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC) getExtensionPtr( "glProgramUniform1f" );
		if ( glProgramUniform1f != 0 )	++localInitializedProcCount;

		glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC) getExtensionPtr( "glProgramUniform1fv" );
		if ( glProgramUniform1fv != 0 )	++localInitializedProcCount;

		glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC) getExtensionPtr( "glProgramUniform1i" );
		if ( glProgramUniform1i != 0 )	++localInitializedProcCount;

		glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC) getExtensionPtr( "glProgramUniform1iv" );
		if ( glProgramUniform1iv != 0 )	++localInitializedProcCount;

		glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC) getExtensionPtr( "glProgramUniform1ui" );
		if ( glProgramUniform1ui != 0 )	++localInitializedProcCount;

		glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC) getExtensionPtr( "glProgramUniform1uiv" );
		if ( glProgramUniform1uiv != 0 )	++localInitializedProcCount;

		glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC) getExtensionPtr( "glProgramUniform2d" );
		if ( glProgramUniform2d != 0 )	++localInitializedProcCount;

		glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC) getExtensionPtr( "glProgramUniform2dv" );
		if ( glProgramUniform2dv != 0 )	++localInitializedProcCount;

		glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC) getExtensionPtr( "glProgramUniform2f" );
		if ( glProgramUniform2f != 0 )	++localInitializedProcCount;

		glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC) getExtensionPtr( "glProgramUniform2fv" );
		if ( glProgramUniform2fv != 0 )	++localInitializedProcCount;

		glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC) getExtensionPtr( "glProgramUniform2i" );
		if ( glProgramUniform2i != 0 )	++localInitializedProcCount;

		glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC) getExtensionPtr( "glProgramUniform2iv" );
		if ( glProgramUniform2iv != 0 )	++localInitializedProcCount;

		glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC) getExtensionPtr( "glProgramUniform2ui" );
		if ( glProgramUniform2ui != 0 )	++localInitializedProcCount;

		glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC) getExtensionPtr( "glProgramUniform2uiv" );
		if ( glProgramUniform2uiv != 0 )	++localInitializedProcCount;

		glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC) getExtensionPtr( "glProgramUniform3d" );
		if ( glProgramUniform3d != 0 )	++localInitializedProcCount;

		glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC) getExtensionPtr( "glProgramUniform3dv" );
		if ( glProgramUniform3dv != 0 )	++localInitializedProcCount;

		glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC) getExtensionPtr( "glProgramUniform3f" );
		if ( glProgramUniform3f != 0 )	++localInitializedProcCount;

		glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC) getExtensionPtr( "glProgramUniform3fv" );
		if ( glProgramUniform3fv != 0 )	++localInitializedProcCount;

		glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC) getExtensionPtr( "glProgramUniform3i" );
		if ( glProgramUniform3i != 0 )	++localInitializedProcCount;

		glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC) getExtensionPtr( "glProgramUniform3iv" );
		if ( glProgramUniform3iv != 0 )	++localInitializedProcCount;

		glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC) getExtensionPtr( "glProgramUniform3ui" );
		if ( glProgramUniform3ui != 0 )	++localInitializedProcCount;

		glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC) getExtensionPtr( "glProgramUniform3uiv" );
		if ( glProgramUniform3uiv != 0 )	++localInitializedProcCount;

		glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC) getExtensionPtr( "glProgramUniform4d" );
		if ( glProgramUniform4d != 0 )	++localInitializedProcCount;

		glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC) getExtensionPtr( "glProgramUniform4dv" );
		if ( glProgramUniform4dv != 0 )	++localInitializedProcCount;

		glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC) getExtensionPtr( "glProgramUniform4f" );
		if ( glProgramUniform4f != 0 )	++localInitializedProcCount;

		glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC) getExtensionPtr( "glProgramUniform4fv" );
		if ( glProgramUniform4fv != 0 )	++localInitializedProcCount;

		glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC) getExtensionPtr( "glProgramUniform4i" );
		if ( glProgramUniform4i != 0 )	++localInitializedProcCount;

		glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC) getExtensionPtr( "glProgramUniform4iv" );
		if ( glProgramUniform4iv != 0 )	++localInitializedProcCount;

		glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC) getExtensionPtr( "glProgramUniform4ui" );
		if ( glProgramUniform4ui != 0 )	++localInitializedProcCount;

		glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC) getExtensionPtr( "glProgramUniform4uiv" );
		if ( glProgramUniform4uiv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC) getExtensionPtr( "glProgramUniformMatrix2dv" );
		if ( glProgramUniformMatrix2dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC) getExtensionPtr( "glProgramUniformMatrix2fv" );
		if ( glProgramUniformMatrix2fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC) getExtensionPtr( "glProgramUniformMatrix2x3dv" );
		if ( glProgramUniformMatrix2x3dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC) getExtensionPtr( "glProgramUniformMatrix2x3fv" );
		if ( glProgramUniformMatrix2x3fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC) getExtensionPtr( "glProgramUniformMatrix2x4dv" );
		if ( glProgramUniformMatrix2x4dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC) getExtensionPtr( "glProgramUniformMatrix2x4fv" );
		if ( glProgramUniformMatrix2x4fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC) getExtensionPtr( "glProgramUniformMatrix3dv" );
		if ( glProgramUniformMatrix3dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC) getExtensionPtr( "glProgramUniformMatrix3fv" );
		if ( glProgramUniformMatrix3fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC) getExtensionPtr( "glProgramUniformMatrix3x2dv" );
		if ( glProgramUniformMatrix3x2dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC) getExtensionPtr( "glProgramUniformMatrix3x2fv" );
		if ( glProgramUniformMatrix3x2fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC) getExtensionPtr( "glProgramUniformMatrix3x4dv" );
		if ( glProgramUniformMatrix3x4dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC) getExtensionPtr( "glProgramUniformMatrix3x4fv" );
		if ( glProgramUniformMatrix3x4fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC) getExtensionPtr( "glProgramUniformMatrix4dv" );
		if ( glProgramUniformMatrix4dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC) getExtensionPtr( "glProgramUniformMatrix4fv" );
		if ( glProgramUniformMatrix4fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC) getExtensionPtr( "glProgramUniformMatrix4x2dv" );
		if ( glProgramUniformMatrix4x2dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC) getExtensionPtr( "glProgramUniformMatrix4x2fv" );
		if ( glProgramUniformMatrix4x2fv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC) getExtensionPtr( "glProgramUniformMatrix4x3dv" );
		if ( glProgramUniformMatrix4x3dv != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC) getExtensionPtr( "glProgramUniformMatrix4x3fv" );
		if ( glProgramUniformMatrix4x3fv != 0 )	++localInitializedProcCount;

		glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC) getExtensionPtr( "glUseProgramStages" );
		if ( glUseProgramStages != 0 )	++localInitializedProcCount;

		glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC) getExtensionPtr( "glValidateProgramPipeline" );
		if ( glValidateProgramPipeline != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_separate_shader_objects )

	if ( isGL_ARB_separate_shader_objects )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_separate_shader_objects                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_separate_shader_objects                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_separate_shader_objects") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_separate_shader_objects                    : not detected." );
	}


	isGL_ARB_shader_atomic_counters = isExtensionSupported("GL_ARB_shader_atomic_counters");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_atomic_counters ) // || isSEDEnable()
	{
		glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC) getExtensionPtr( "glGetActiveAtomicCounterBufferiv" );
		if ( glGetActiveAtomicCounterBufferiv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_shader_atomic_counters )

	if ( isGL_ARB_shader_atomic_counters )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_atomic_counters                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_atomic_counters                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_atomic_counters") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_atomic_counters                     : not detected." );
	}


	isGL_ARB_shader_bit_encoding = isExtensionSupported("GL_ARB_shader_bit_encoding");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_bit_encoding )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_bit_encoding                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_bit_encoding                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_bit_encoding") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_bit_encoding                        : not detected." );
	}


	isGL_ARB_shader_image_load_store = isExtensionSupported("GL_ARB_shader_image_load_store");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_image_load_store ) // || isSEDEnable()
	{
		glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC) getExtensionPtr( "glBindImageTexture" );
		if ( glBindImageTexture != 0 )	++localInitializedProcCount;

		glMemoryBarrier = (PFNGLMEMORYBARRIERPROC) getExtensionPtr( "glMemoryBarrier" );
		if ( glMemoryBarrier != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_shader_image_load_store )

	if ( isGL_ARB_shader_image_load_store )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_image_load_store                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_image_load_store                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_image_load_store") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_image_load_store                    : not detected." );
	}


	isGL_ARB_shader_image_size = isExtensionSupported("GL_ARB_shader_image_size");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_image_size )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_image_size                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_image_size                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_image_size") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_image_size                          : not detected." );
	}


	isGL_ARB_shader_objects = isExtensionSupported("GL_ARB_shader_objects");

	localSupportedProcCount		= 39;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_objects ) // || isSEDEnable()
	{
		glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) getExtensionPtr( "glAttachObjectARB" );
		if ( glAttachObjectARB != 0 )	++localInitializedProcCount;

		glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) getExtensionPtr( "glCompileShaderARB" );
		if ( glCompileShaderARB != 0 )	++localInitializedProcCount;

		glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) getExtensionPtr( "glCreateProgramObjectARB" );
		if ( glCreateProgramObjectARB != 0 )	++localInitializedProcCount;

		glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) getExtensionPtr( "glCreateShaderObjectARB" );
		if ( glCreateShaderObjectARB != 0 )	++localInitializedProcCount;

		glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) getExtensionPtr( "glDeleteObjectARB" );
		if ( glDeleteObjectARB != 0 )	++localInitializedProcCount;

		glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC) getExtensionPtr( "glDetachObjectARB" );
		if ( glDetachObjectARB != 0 )	++localInitializedProcCount;

		glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) getExtensionPtr( "glGetActiveUniformARB" );
		if ( glGetActiveUniformARB != 0 )	++localInitializedProcCount;

		glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC) getExtensionPtr( "glGetAttachedObjectsARB" );
		if ( glGetAttachedObjectsARB != 0 )	++localInitializedProcCount;

		glGetHandleARB = (PFNGLGETHANDLEARBPROC) getExtensionPtr( "glGetHandleARB" );
		if ( glGetHandleARB != 0 )	++localInitializedProcCount;

		glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) getExtensionPtr( "glGetInfoLogARB" );
		if ( glGetInfoLogARB != 0 )	++localInitializedProcCount;

		glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC) getExtensionPtr( "glGetObjectParameterfvARB" );
		if ( glGetObjectParameterfvARB != 0 )	++localInitializedProcCount;

		glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) getExtensionPtr( "glGetObjectParameterivARB" );
		if ( glGetObjectParameterivARB != 0 )	++localInitializedProcCount;

		glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC) getExtensionPtr( "glGetShaderSourceARB" );
		if ( glGetShaderSourceARB != 0 )	++localInitializedProcCount;

		glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) getExtensionPtr( "glGetUniformLocationARB" );
		if ( glGetUniformLocationARB != 0 )	++localInitializedProcCount;

		glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC) getExtensionPtr( "glGetUniformfvARB" );
		if ( glGetUniformfvARB != 0 )	++localInitializedProcCount;

		glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC) getExtensionPtr( "glGetUniformivARB" );
		if ( glGetUniformivARB != 0 )	++localInitializedProcCount;

		glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) getExtensionPtr( "glLinkProgramARB" );
		if ( glLinkProgramARB != 0 )	++localInitializedProcCount;

		glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) getExtensionPtr( "glShaderSourceARB" );
		if ( glShaderSourceARB != 0 )	++localInitializedProcCount;

		glUniform1fARB = (PFNGLUNIFORM1FARBPROC) getExtensionPtr( "glUniform1fARB" );
		if ( glUniform1fARB != 0 )	++localInitializedProcCount;

		glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) getExtensionPtr( "glUniform1fvARB" );
		if ( glUniform1fvARB != 0 )	++localInitializedProcCount;

		glUniform1iARB = (PFNGLUNIFORM1IARBPROC) getExtensionPtr( "glUniform1iARB" );
		if ( glUniform1iARB != 0 )	++localInitializedProcCount;

		glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) getExtensionPtr( "glUniform1ivARB" );
		if ( glUniform1ivARB != 0 )	++localInitializedProcCount;

		glUniform2fARB = (PFNGLUNIFORM2FARBPROC) getExtensionPtr( "glUniform2fARB" );
		if ( glUniform2fARB != 0 )	++localInitializedProcCount;

		glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) getExtensionPtr( "glUniform2fvARB" );
		if ( glUniform2fvARB != 0 )	++localInitializedProcCount;

		glUniform2iARB = (PFNGLUNIFORM2IARBPROC) getExtensionPtr( "glUniform2iARB" );
		if ( glUniform2iARB != 0 )	++localInitializedProcCount;

		glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC) getExtensionPtr( "glUniform2ivARB" );
		if ( glUniform2ivARB != 0 )	++localInitializedProcCount;

		glUniform3fARB = (PFNGLUNIFORM3FARBPROC) getExtensionPtr( "glUniform3fARB" );
		if ( glUniform3fARB != 0 )	++localInitializedProcCount;

		glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) getExtensionPtr( "glUniform3fvARB" );
		if ( glUniform3fvARB != 0 )	++localInitializedProcCount;

		glUniform3iARB = (PFNGLUNIFORM3IARBPROC) getExtensionPtr( "glUniform3iARB" );
		if ( glUniform3iARB != 0 )	++localInitializedProcCount;

		glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC) getExtensionPtr( "glUniform3ivARB" );
		if ( glUniform3ivARB != 0 )	++localInitializedProcCount;

		glUniform4fARB = (PFNGLUNIFORM4FARBPROC) getExtensionPtr( "glUniform4fARB" );
		if ( glUniform4fARB != 0 )	++localInitializedProcCount;

		glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) getExtensionPtr( "glUniform4fvARB" );
		if ( glUniform4fvARB != 0 )	++localInitializedProcCount;

		glUniform4iARB = (PFNGLUNIFORM4IARBPROC) getExtensionPtr( "glUniform4iARB" );
		if ( glUniform4iARB != 0 )	++localInitializedProcCount;

		glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC) getExtensionPtr( "glUniform4ivARB" );
		if ( glUniform4ivARB != 0 )	++localInitializedProcCount;

		glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) getExtensionPtr( "glUniformMatrix2fvARB" );
		if ( glUniformMatrix2fvARB != 0 )	++localInitializedProcCount;

		glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) getExtensionPtr( "glUniformMatrix3fvARB" );
		if ( glUniformMatrix3fvARB != 0 )	++localInitializedProcCount;

		glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) getExtensionPtr( "glUniformMatrix4fvARB" );
		if ( glUniformMatrix4fvARB != 0 )	++localInitializedProcCount;

		glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) getExtensionPtr( "glUseProgramObjectARB" );
		if ( glUseProgramObjectARB != 0 )	++localInitializedProcCount;

		glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC) getExtensionPtr( "glValidateProgramARB" );
		if ( glValidateProgramARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_shader_objects )

	if ( isGL_ARB_shader_objects )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_objects                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_objects                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_objects") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_objects                             : not detected." );
	}


	isGL_ARB_shader_precision = isExtensionSupported("GL_ARB_shader_precision");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_precision )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_precision                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_precision                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_precision") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_precision                           : not detected." );
	}


	isGL_ARB_shader_stencil_export = isExtensionSupported("GL_ARB_shader_stencil_export");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_stencil_export )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_stencil_export                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_stencil_export                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_stencil_export") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_stencil_export                      : not detected." );
	}


	isGL_ARB_shader_storage_buffer_object = isExtensionSupported("GL_ARB_shader_storage_buffer_object");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_storage_buffer_object ) // || isSEDEnable()
	{
		glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC) getExtensionPtr( "glShaderStorageBlockBinding" );
		if ( glShaderStorageBlockBinding != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_shader_storage_buffer_object )

	if ( isGL_ARB_shader_storage_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_storage_buffer_object               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_storage_buffer_object               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_storage_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_storage_buffer_object               : not detected." );
	}


	isGL_ARB_shader_subroutine = isExtensionSupported("GL_ARB_shader_subroutine");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_subroutine ) // || isSEDEnable()
	{
		glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC) getExtensionPtr( "glGetActiveSubroutineName" );
		if ( glGetActiveSubroutineName != 0 )	++localInitializedProcCount;

		glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC) getExtensionPtr( "glGetActiveSubroutineUniformName" );
		if ( glGetActiveSubroutineUniformName != 0 )	++localInitializedProcCount;

		glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC) getExtensionPtr( "glGetActiveSubroutineUniformiv" );
		if ( glGetActiveSubroutineUniformiv != 0 )	++localInitializedProcCount;

		glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC) getExtensionPtr( "glGetProgramStageiv" );
		if ( glGetProgramStageiv != 0 )	++localInitializedProcCount;

		glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC) getExtensionPtr( "glGetSubroutineIndex" );
		if ( glGetSubroutineIndex != 0 )	++localInitializedProcCount;

		glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC) getExtensionPtr( "glGetSubroutineUniformLocation" );
		if ( glGetSubroutineUniformLocation != 0 )	++localInitializedProcCount;

		glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC) getExtensionPtr( "glGetUniformSubroutineuiv" );
		if ( glGetUniformSubroutineuiv != 0 )	++localInitializedProcCount;

		glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC) getExtensionPtr( "glUniformSubroutinesuiv" );
		if ( glUniformSubroutinesuiv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_shader_subroutine )

	if ( isGL_ARB_shader_subroutine )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_subroutine                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_subroutine                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_subroutine") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_subroutine                          : not detected." );
	}


	isGL_ARB_shader_texture_lod = isExtensionSupported("GL_ARB_shader_texture_lod");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shader_texture_lod )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shader_texture_lod                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shader_texture_lod                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shader_texture_lod") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shader_texture_lod                         : not detected." );
	}


	isGL_ARB_shading_language_100 = isExtensionSupported("GL_ARB_shading_language_100");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shading_language_100 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shading_language_100                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shading_language_100                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shading_language_100") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shading_language_100                       : not detected." );
	}


	isGL_ARB_shading_language_420pack = isExtensionSupported("GL_ARB_shading_language_420pack");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shading_language_420pack )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shading_language_420pack                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shading_language_420pack                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shading_language_420pack") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shading_language_420pack                   : not detected." );
	}


	isGL_ARB_shading_language_include = isExtensionSupported("GL_ARB_shading_language_include");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shading_language_include ) // || isSEDEnable()
	{
		glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC) getExtensionPtr( "glCompileShaderIncludeARB" );
		if ( glCompileShaderIncludeARB != 0 )	++localInitializedProcCount;

		glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC) getExtensionPtr( "glDeleteNamedStringARB" );
		if ( glDeleteNamedStringARB != 0 )	++localInitializedProcCount;

		glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC) getExtensionPtr( "glGetNamedStringARB" );
		if ( glGetNamedStringARB != 0 )	++localInitializedProcCount;

		glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC) getExtensionPtr( "glGetNamedStringivARB" );
		if ( glGetNamedStringivARB != 0 )	++localInitializedProcCount;

		glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC) getExtensionPtr( "glIsNamedStringARB" );
		if ( glIsNamedStringARB != 0 )	++localInitializedProcCount;

		glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC) getExtensionPtr( "glNamedStringARB" );
		if ( glNamedStringARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_shading_language_include )

	if ( isGL_ARB_shading_language_include )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shading_language_include                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shading_language_include                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shading_language_include") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shading_language_include                   : not detected." );
	}


	isGL_ARB_shading_language_packing = isExtensionSupported("GL_ARB_shading_language_packing");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shading_language_packing )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shading_language_packing                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shading_language_packing                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shading_language_packing") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shading_language_packing                   : not detected." );
	}


	isGL_ARB_shadow = isExtensionSupported("GL_ARB_shadow");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shadow )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shadow                                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shadow                                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shadow") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shadow                                     : not detected." );
	}


	isGL_ARB_shadow_ambient = isExtensionSupported("GL_ARB_shadow_ambient");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_shadow_ambient )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_shadow_ambient                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_shadow_ambient                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_shadow_ambient") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_shadow_ambient                             : not detected." );
	}


	isGL_ARB_stencil_texturing = isExtensionSupported("GL_ARB_stencil_texturing");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_stencil_texturing )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_stencil_texturing                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_stencil_texturing                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_stencil_texturing") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_stencil_texturing                          : not detected." );
	}


	isGL_ARB_sync = isExtensionSupported("GL_ARB_sync");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_sync ) // || isSEDEnable()
	{
		glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) getExtensionPtr( "glClientWaitSync" );
		if ( glClientWaitSync != 0 )	++localInitializedProcCount;

		glDeleteSync = (PFNGLDELETESYNCPROC) getExtensionPtr( "glDeleteSync" );
		if ( glDeleteSync != 0 )	++localInitializedProcCount;

		glFenceSync = (PFNGLFENCESYNCPROC) getExtensionPtr( "glFenceSync" );
		if ( glFenceSync != 0 )	++localInitializedProcCount;

		glGetInteger64v = (PFNGLGETINTEGER64VPROC) getExtensionPtr( "glGetInteger64v" );
		if ( glGetInteger64v != 0 )	++localInitializedProcCount;

		glGetSynciv = (PFNGLGETSYNCIVPROC) getExtensionPtr( "glGetSynciv" );
		if ( glGetSynciv != 0 )	++localInitializedProcCount;

		glIsSync = (PFNGLISSYNCPROC) getExtensionPtr( "glIsSync" );
		if ( glIsSync != 0 )	++localInitializedProcCount;

		glWaitSync = (PFNGLWAITSYNCPROC) getExtensionPtr( "glWaitSync" );
		if ( glWaitSync != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_sync )

	if ( isGL_ARB_sync )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_sync                                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_sync                                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_sync") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_sync                                       : not detected." );
	}


	isGL_ARB_tessellation_shader = isExtensionSupported("GL_ARB_tessellation_shader");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_tessellation_shader ) // || isSEDEnable()
	{
		glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC) getExtensionPtr( "glPatchParameterfv" );
		if ( glPatchParameterfv != 0 )	++localInitializedProcCount;

		glPatchParameteri = (PFNGLPATCHPARAMETERIPROC) getExtensionPtr( "glPatchParameteri" );
		if ( glPatchParameteri != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_tessellation_shader )

	if ( isGL_ARB_tessellation_shader )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_tessellation_shader                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_tessellation_shader                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_tessellation_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_tessellation_shader                        : not detected." );
	}


	isGL_ARB_texture_border_clamp = isExtensionSupported("GL_ARB_texture_border_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_border_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_border_clamp                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_border_clamp                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_border_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_border_clamp                       : not detected." );
	}


	isGL_ARB_texture_buffer_object = isExtensionSupported("GL_ARB_texture_buffer_object");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_buffer_object ) // || isSEDEnable()
	{
		glTexBufferARB = (PFNGLTEXBUFFERARBPROC) getExtensionPtr( "glTexBufferARB" );
		if ( glTexBufferARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_buffer_object )

	if ( isGL_ARB_texture_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_buffer_object                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_buffer_object                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_buffer_object                      : not detected." );
	}


	isGL_ARB_texture_buffer_object_rgb32 = isExtensionSupported("GL_ARB_texture_buffer_object_rgb32");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_buffer_object_rgb32 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_buffer_object_rgb32                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_buffer_object_rgb32                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_buffer_object_rgb32") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_buffer_object_rgb32                : not detected." );
	}


	isGL_ARB_texture_buffer_range = isExtensionSupported("GL_ARB_texture_buffer_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_buffer_range ) // || isSEDEnable()
	{
		glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC) getExtensionPtr( "glTexBufferRange" );
		if ( glTexBufferRange != 0 )	++localInitializedProcCount;

		glTextureBufferRangeEXT = (PFNGLTEXTUREBUFFERRANGEEXTPROC) getExtensionPtr( "glTextureBufferRangeEXT" );
		if ( glTextureBufferRangeEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_buffer_range )

	if ( isGL_ARB_texture_buffer_range )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_buffer_range                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_buffer_range                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_buffer_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_buffer_range                       : not detected." );
	}


	isGL_ARB_texture_compression = isExtensionSupported("GL_ARB_texture_compression");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_compression ) // || isSEDEnable()
	{
		glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) getExtensionPtr( "glCompressedTexImage1DARB" );
		if ( glCompressedTexImage1DARB != 0 )	++localInitializedProcCount;

		glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) getExtensionPtr( "glCompressedTexImage2DARB" );
		if ( glCompressedTexImage2DARB != 0 )	++localInitializedProcCount;

		glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) getExtensionPtr( "glCompressedTexImage3DARB" );
		if ( glCompressedTexImage3DARB != 0 )	++localInitializedProcCount;

		glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) getExtensionPtr( "glCompressedTexSubImage1DARB" );
		if ( glCompressedTexSubImage1DARB != 0 )	++localInitializedProcCount;

		glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) getExtensionPtr( "glCompressedTexSubImage2DARB" );
		if ( glCompressedTexSubImage2DARB != 0 )	++localInitializedProcCount;

		glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) getExtensionPtr( "glCompressedTexSubImage3DARB" );
		if ( glCompressedTexSubImage3DARB != 0 )	++localInitializedProcCount;

		glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) getExtensionPtr( "glGetCompressedTexImageARB" );
		if ( glGetCompressedTexImageARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_compression )

	if ( isGL_ARB_texture_compression )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_compression                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_compression                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_compression") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_compression                        : not detected." );
	}


	isGL_ARB_texture_compression_bptc = isExtensionSupported("GL_ARB_texture_compression_bptc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_compression_bptc )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_compression_bptc                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_compression_bptc                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_compression_bptc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_compression_bptc                   : not detected." );
	}


	isGL_ARB_texture_compression_rgtc = isExtensionSupported("GL_ARB_texture_compression_rgtc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_compression_rgtc )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_compression_rgtc                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_compression_rgtc                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_compression_rgtc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_compression_rgtc                   : not detected." );
	}


	isGL_ARB_texture_cube_map = isExtensionSupported("GL_ARB_texture_cube_map");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_cube_map )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_cube_map                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_cube_map                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_cube_map") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_cube_map                           : not detected." );
	}


	isGL_ARB_texture_cube_map_array = isExtensionSupported("GL_ARB_texture_cube_map_array");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_cube_map_array )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_cube_map_array                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_cube_map_array                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_cube_map_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_cube_map_array                     : not detected." );
	}


	isGL_ARB_texture_env_add = isExtensionSupported("GL_ARB_texture_env_add");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_env_add )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_env_add                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_env_add                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_env_add") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_env_add                            : not detected." );
	}


	isGL_ARB_texture_env_combine = isExtensionSupported("GL_ARB_texture_env_combine");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_env_combine )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_env_combine                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_env_combine                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_env_combine") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_env_combine                        : not detected." );
	}


	isGL_ARB_texture_env_crossbar = isExtensionSupported("GL_ARB_texture_env_crossbar");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_env_crossbar )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_env_crossbar                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_env_crossbar                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_env_crossbar") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_env_crossbar                       : not detected." );
	}


	isGL_ARB_texture_env_dot3 = isExtensionSupported("GL_ARB_texture_env_dot3");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_env_dot3 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_env_dot3                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_env_dot3                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_env_dot3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_env_dot3                           : not detected." );
	}


	isGL_ARB_texture_float = isExtensionSupported("GL_ARB_texture_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_float )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_float                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_float                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_float                              : not detected." );
	}


	isGL_ARB_texture_gather = isExtensionSupported("GL_ARB_texture_gather");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_gather )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_gather                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_gather                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_gather") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_gather                             : not detected." );
	}


	isGL_ARB_texture_mirrored_repeat = isExtensionSupported("GL_ARB_texture_mirrored_repeat");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_mirrored_repeat )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_mirrored_repeat                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_mirrored_repeat                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_mirrored_repeat") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_mirrored_repeat                    : not detected." );
	}


	isGL_ARB_texture_multisample = isExtensionSupported("GL_ARB_texture_multisample");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_multisample ) // || isSEDEnable()
	{
		glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) getExtensionPtr( "glGetMultisamplefv" );
		if ( glGetMultisamplefv != 0 )	++localInitializedProcCount;

		glSampleMaski = (PFNGLSAMPLEMASKIPROC) getExtensionPtr( "glSampleMaski" );
		if ( glSampleMaski != 0 )	++localInitializedProcCount;

		glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) getExtensionPtr( "glTexImage2DMultisample" );
		if ( glTexImage2DMultisample != 0 )	++localInitializedProcCount;

		glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) getExtensionPtr( "glTexImage3DMultisample" );
		if ( glTexImage3DMultisample != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_multisample )

	if ( isGL_ARB_texture_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_multisample                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_multisample                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_multisample                        : not detected." );
	}


	isGL_ARB_texture_non_power_of_two = isExtensionSupported("GL_ARB_texture_non_power_of_two");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_non_power_of_two )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_non_power_of_two                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_non_power_of_two                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_non_power_of_two") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_non_power_of_two                   : not detected." );
	}


	isGL_ARB_texture_query_levels = isExtensionSupported("GL_ARB_texture_query_levels");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_query_levels )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_query_levels                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_query_levels                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_query_levels") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_query_levels                       : not detected." );
	}


	isGL_ARB_texture_query_lod = isExtensionSupported("GL_ARB_texture_query_lod");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_query_lod )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_query_lod                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_query_lod                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_query_lod") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_query_lod                          : not detected." );
	}


	isGL_ARB_texture_rectangle = isExtensionSupported("GL_ARB_texture_rectangle");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_rectangle )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_rectangle                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_rectangle                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_rectangle") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_rectangle                          : not detected." );
	}


	isGL_ARB_texture_rg = isExtensionSupported("GL_ARB_texture_rg");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_rg )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_rg                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_rg                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_rg") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_rg                                 : not detected." );
	}


	isGL_ARB_texture_rgb10_a2ui = isExtensionSupported("GL_ARB_texture_rgb10_a2ui");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_rgb10_a2ui )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_rgb10_a2ui                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_rgb10_a2ui                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_rgb10_a2ui") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_rgb10_a2ui                         : not detected." );
	}


	isGL_ARB_texture_storage = isExtensionSupported("GL_ARB_texture_storage");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_storage ) // || isSEDEnable()
	{
		glTexStorage1D = (PFNGLTEXSTORAGE1DPROC) getExtensionPtr( "glTexStorage1D" );
		if ( glTexStorage1D != 0 )	++localInitializedProcCount;

		glTexStorage2D = (PFNGLTEXSTORAGE2DPROC) getExtensionPtr( "glTexStorage2D" );
		if ( glTexStorage2D != 0 )	++localInitializedProcCount;

		glTexStorage3D = (PFNGLTEXSTORAGE3DPROC) getExtensionPtr( "glTexStorage3D" );
		if ( glTexStorage3D != 0 )	++localInitializedProcCount;

		glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC) getExtensionPtr( "glTextureStorage1DEXT" );
		if ( glTextureStorage1DEXT != 0 )	++localInitializedProcCount;

		glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC) getExtensionPtr( "glTextureStorage2DEXT" );
		if ( glTextureStorage2DEXT != 0 )	++localInitializedProcCount;

		glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC) getExtensionPtr( "glTextureStorage3DEXT" );
		if ( glTextureStorage3DEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_storage )

	if ( isGL_ARB_texture_storage )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_storage                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_storage                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_storage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_storage                            : not detected." );
	}


	isGL_ARB_texture_storage_multisample = isExtensionSupported("GL_ARB_texture_storage_multisample");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_storage_multisample ) // || isSEDEnable()
	{
		glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC) getExtensionPtr( "glTexStorage2DMultisample" );
		if ( glTexStorage2DMultisample != 0 )	++localInitializedProcCount;

		glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC) getExtensionPtr( "glTexStorage3DMultisample" );
		if ( glTexStorage3DMultisample != 0 )	++localInitializedProcCount;

		glTextureStorage2DMultisampleEXT = (PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC) getExtensionPtr( "glTextureStorage2DMultisampleEXT" );
		if ( glTextureStorage2DMultisampleEXT != 0 )	++localInitializedProcCount;

		glTextureStorage3DMultisampleEXT = (PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC) getExtensionPtr( "glTextureStorage3DMultisampleEXT" );
		if ( glTextureStorage3DMultisampleEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_storage_multisample )

	if ( isGL_ARB_texture_storage_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_storage_multisample                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_storage_multisample                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_storage_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_storage_multisample                : not detected." );
	}


	isGL_ARB_texture_swizzle = isExtensionSupported("GL_ARB_texture_swizzle");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_swizzle )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_swizzle                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_swizzle                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_swizzle") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_swizzle                            : not detected." );
	}


	isGL_ARB_texture_view = isExtensionSupported("GL_ARB_texture_view");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_texture_view ) // || isSEDEnable()
	{
		glTextureView = (PFNGLTEXTUREVIEWPROC) getExtensionPtr( "glTextureView" );
		if ( glTextureView != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_texture_view )

	if ( isGL_ARB_texture_view )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_texture_view                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_texture_view                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_texture_view") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_texture_view                               : not detected." );
	}


	isGL_ARB_timer_query = isExtensionSupported("GL_ARB_timer_query");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_timer_query ) // || isSEDEnable()
	{
		glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC) getExtensionPtr( "glGetQueryObjecti64v" );
		if ( glGetQueryObjecti64v != 0 )	++localInitializedProcCount;

		glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC) getExtensionPtr( "glGetQueryObjectui64v" );
		if ( glGetQueryObjectui64v != 0 )	++localInitializedProcCount;

		glQueryCounter = (PFNGLQUERYCOUNTERPROC) getExtensionPtr( "glQueryCounter" );
		if ( glQueryCounter != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_timer_query )

	if ( isGL_ARB_timer_query )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_timer_query                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_timer_query                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_timer_query") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_timer_query                                : not detected." );
	}


	isGL_ARB_transform_feedback2 = isExtensionSupported("GL_ARB_transform_feedback2");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_transform_feedback2 ) // || isSEDEnable()
	{
		glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC) getExtensionPtr( "glBindTransformFeedback" );
		if ( glBindTransformFeedback != 0 )	++localInitializedProcCount;

		glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC) getExtensionPtr( "glDeleteTransformFeedbacks" );
		if ( glDeleteTransformFeedbacks != 0 )	++localInitializedProcCount;

		glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC) getExtensionPtr( "glDrawTransformFeedback" );
		if ( glDrawTransformFeedback != 0 )	++localInitializedProcCount;

		glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC) getExtensionPtr( "glGenTransformFeedbacks" );
		if ( glGenTransformFeedbacks != 0 )	++localInitializedProcCount;

		glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC) getExtensionPtr( "glIsTransformFeedback" );
		if ( glIsTransformFeedback != 0 )	++localInitializedProcCount;

		glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC) getExtensionPtr( "glPauseTransformFeedback" );
		if ( glPauseTransformFeedback != 0 )	++localInitializedProcCount;

		glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC) getExtensionPtr( "glResumeTransformFeedback" );
		if ( glResumeTransformFeedback != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_transform_feedback2 )

	if ( isGL_ARB_transform_feedback2 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_transform_feedback2                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_transform_feedback2                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_transform_feedback2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_transform_feedback2                        : not detected." );
	}


	isGL_ARB_transform_feedback3 = isExtensionSupported("GL_ARB_transform_feedback3");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_transform_feedback3 ) // || isSEDEnable()
	{
		glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC) getExtensionPtr( "glBeginQueryIndexed" );
		if ( glBeginQueryIndexed != 0 )	++localInitializedProcCount;

		glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC) getExtensionPtr( "glDrawTransformFeedbackStream" );
		if ( glDrawTransformFeedbackStream != 0 )	++localInitializedProcCount;

		glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC) getExtensionPtr( "glEndQueryIndexed" );
		if ( glEndQueryIndexed != 0 )	++localInitializedProcCount;

		glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC) getExtensionPtr( "glGetQueryIndexediv" );
		if ( glGetQueryIndexediv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_transform_feedback3 )

	if ( isGL_ARB_transform_feedback3 )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_transform_feedback3                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_transform_feedback3                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_transform_feedback3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_transform_feedback3                        : not detected." );
	}


	isGL_ARB_transform_feedback_instanced = isExtensionSupported("GL_ARB_transform_feedback_instanced");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_transform_feedback_instanced ) // || isSEDEnable()
	{
		glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC) getExtensionPtr( "glDrawTransformFeedbackInstanced" );
		if ( glDrawTransformFeedbackInstanced != 0 )	++localInitializedProcCount;

		glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC) getExtensionPtr( "glDrawTransformFeedbackStreamInstanced" );
		if ( glDrawTransformFeedbackStreamInstanced != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_transform_feedback_instanced )

	if ( isGL_ARB_transform_feedback_instanced )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_transform_feedback_instanced               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_transform_feedback_instanced               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_transform_feedback_instanced") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_transform_feedback_instanced               : not detected." );
	}


	isGL_ARB_transpose_matrix = isExtensionSupported("GL_ARB_transpose_matrix");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_transpose_matrix ) // || isSEDEnable()
	{
		glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC) getExtensionPtr( "glLoadTransposeMatrixdARB" );
		if ( glLoadTransposeMatrixdARB != 0 )	++localInitializedProcCount;

		glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC) getExtensionPtr( "glLoadTransposeMatrixfARB" );
		if ( glLoadTransposeMatrixfARB != 0 )	++localInitializedProcCount;

		glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC) getExtensionPtr( "glMultTransposeMatrixdARB" );
		if ( glMultTransposeMatrixdARB != 0 )	++localInitializedProcCount;

		glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC) getExtensionPtr( "glMultTransposeMatrixfARB" );
		if ( glMultTransposeMatrixfARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_transpose_matrix )

	if ( isGL_ARB_transpose_matrix )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_transpose_matrix                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_transpose_matrix                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_transpose_matrix") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_transpose_matrix                           : not detected." );
	}


	isGL_ARB_uniform_buffer_object = isExtensionSupported("GL_ARB_uniform_buffer_object");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_uniform_buffer_object ) // || isSEDEnable()
	{
		glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) getExtensionPtr( "glGetActiveUniformBlockName" );
		if ( glGetActiveUniformBlockName != 0 )	++localInitializedProcCount;

		glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) getExtensionPtr( "glGetActiveUniformBlockiv" );
		if ( glGetActiveUniformBlockiv != 0 )	++localInitializedProcCount;

		glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) getExtensionPtr( "glGetActiveUniformName" );
		if ( glGetActiveUniformName != 0 )	++localInitializedProcCount;

		glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) getExtensionPtr( "glGetActiveUniformsiv" );
		if ( glGetActiveUniformsiv != 0 )	++localInitializedProcCount;

		glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) getExtensionPtr( "glGetUniformBlockIndex" );
		if ( glGetUniformBlockIndex != 0 )	++localInitializedProcCount;

		glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) getExtensionPtr( "glGetUniformIndices" );
		if ( glGetUniformIndices != 0 )	++localInitializedProcCount;

		glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) getExtensionPtr( "glUniformBlockBinding" );
		if ( glUniformBlockBinding != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_uniform_buffer_object )

	if ( isGL_ARB_uniform_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_uniform_buffer_object                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_uniform_buffer_object                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_uniform_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_uniform_buffer_object                      : not detected." );
	}


	isGL_ARB_vertex_array_bgra = isExtensionSupported("GL_ARB_vertex_array_bgra");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_array_bgra )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_array_bgra                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_array_bgra                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_array_bgra") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_array_bgra                          : not detected." );
	}


	isGL_ARB_vertex_array_object = isExtensionSupported("GL_ARB_vertex_array_object");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_array_object ) // || isSEDEnable()
	{
		glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) getExtensionPtr( "glBindVertexArray" );
		if ( glBindVertexArray != 0 )	++localInitializedProcCount;

		glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) getExtensionPtr( "glDeleteVertexArrays" );
		if ( glDeleteVertexArrays != 0 )	++localInitializedProcCount;

		glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) getExtensionPtr( "glGenVertexArrays" );
		if ( glGenVertexArrays != 0 )	++localInitializedProcCount;

		glIsVertexArray = (PFNGLISVERTEXARRAYPROC) getExtensionPtr( "glIsVertexArray" );
		if ( glIsVertexArray != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_array_object )

	if ( isGL_ARB_vertex_array_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_array_object                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_array_object                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_array_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_array_object                        : not detected." );
	}


	isGL_ARB_vertex_attrib_64bit = isExtensionSupported("GL_ARB_vertex_attrib_64bit");

	localSupportedProcCount		= 10;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_attrib_64bit ) // || isSEDEnable()
	{
		glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC) getExtensionPtr( "glGetVertexAttribLdv" );
		if ( glGetVertexAttribLdv != 0 )	++localInitializedProcCount;

		glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC) getExtensionPtr( "glVertexAttribL1d" );
		if ( glVertexAttribL1d != 0 )	++localInitializedProcCount;

		glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC) getExtensionPtr( "glVertexAttribL1dv" );
		if ( glVertexAttribL1dv != 0 )	++localInitializedProcCount;

		glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC) getExtensionPtr( "glVertexAttribL2d" );
		if ( glVertexAttribL2d != 0 )	++localInitializedProcCount;

		glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC) getExtensionPtr( "glVertexAttribL2dv" );
		if ( glVertexAttribL2dv != 0 )	++localInitializedProcCount;

		glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC) getExtensionPtr( "glVertexAttribL3d" );
		if ( glVertexAttribL3d != 0 )	++localInitializedProcCount;

		glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC) getExtensionPtr( "glVertexAttribL3dv" );
		if ( glVertexAttribL3dv != 0 )	++localInitializedProcCount;

		glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC) getExtensionPtr( "glVertexAttribL4d" );
		if ( glVertexAttribL4d != 0 )	++localInitializedProcCount;

		glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC) getExtensionPtr( "glVertexAttribL4dv" );
		if ( glVertexAttribL4dv != 0 )	++localInitializedProcCount;

		glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC) getExtensionPtr( "glVertexAttribLPointer" );
		if ( glVertexAttribLPointer != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_attrib_64bit )

	if ( isGL_ARB_vertex_attrib_64bit )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_attrib_64bit                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_attrib_64bit                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_attrib_64bit") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_attrib_64bit                        : not detected." );
	}


	isGL_ARB_vertex_attrib_binding = isExtensionSupported("GL_ARB_vertex_attrib_binding");

	localSupportedProcCount		= 12;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_attrib_binding ) // || isSEDEnable()
	{
		glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC) getExtensionPtr( "glBindVertexBuffer" );
		if ( glBindVertexBuffer != 0 )	++localInitializedProcCount;

		glVertexArrayBindVertexBufferEXT = (PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC) getExtensionPtr( "glVertexArrayBindVertexBufferEXT" );
		if ( glVertexArrayBindVertexBufferEXT != 0 )	++localInitializedProcCount;

		glVertexArrayVertexAttribBindingEXT = (PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC) getExtensionPtr( "glVertexArrayVertexAttribBindingEXT" );
		if ( glVertexArrayVertexAttribBindingEXT != 0 )	++localInitializedProcCount;

		glVertexArrayVertexAttribFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC) getExtensionPtr( "glVertexArrayVertexAttribFormatEXT" );
		if ( glVertexArrayVertexAttribFormatEXT != 0 )	++localInitializedProcCount;

		glVertexArrayVertexAttribIFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC) getExtensionPtr( "glVertexArrayVertexAttribIFormatEXT" );
		if ( glVertexArrayVertexAttribIFormatEXT != 0 )	++localInitializedProcCount;

		glVertexArrayVertexAttribLFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC) getExtensionPtr( "glVertexArrayVertexAttribLFormatEXT" );
		if ( glVertexArrayVertexAttribLFormatEXT != 0 )	++localInitializedProcCount;

		glVertexArrayVertexBindingDivisorEXT = (PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC) getExtensionPtr( "glVertexArrayVertexBindingDivisorEXT" );
		if ( glVertexArrayVertexBindingDivisorEXT != 0 )	++localInitializedProcCount;

		glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC) getExtensionPtr( "glVertexAttribBinding" );
		if ( glVertexAttribBinding != 0 )	++localInitializedProcCount;

		glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC) getExtensionPtr( "glVertexAttribFormat" );
		if ( glVertexAttribFormat != 0 )	++localInitializedProcCount;

		glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC) getExtensionPtr( "glVertexAttribIFormat" );
		if ( glVertexAttribIFormat != 0 )	++localInitializedProcCount;

		glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC) getExtensionPtr( "glVertexAttribLFormat" );
		if ( glVertexAttribLFormat != 0 )	++localInitializedProcCount;

		glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC) getExtensionPtr( "glVertexBindingDivisor" );
		if ( glVertexBindingDivisor != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_attrib_binding )

	if ( isGL_ARB_vertex_attrib_binding )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_attrib_binding                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_attrib_binding                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_attrib_binding") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_attrib_binding                      : not detected." );
	}


	isGL_ARB_vertex_blend = isExtensionSupported("GL_ARB_vertex_blend");

	localSupportedProcCount		= 10;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_blend ) // || isSEDEnable()
	{
		glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC) getExtensionPtr( "glVertexBlendARB" );
		if ( glVertexBlendARB != 0 )	++localInitializedProcCount;

		glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC) getExtensionPtr( "glWeightPointerARB" );
		if ( glWeightPointerARB != 0 )	++localInitializedProcCount;

		glWeightbvARB = (PFNGLWEIGHTBVARBPROC) getExtensionPtr( "glWeightbvARB" );
		if ( glWeightbvARB != 0 )	++localInitializedProcCount;

		glWeightdvARB = (PFNGLWEIGHTDVARBPROC) getExtensionPtr( "glWeightdvARB" );
		if ( glWeightdvARB != 0 )	++localInitializedProcCount;

		glWeightfvARB = (PFNGLWEIGHTFVARBPROC) getExtensionPtr( "glWeightfvARB" );
		if ( glWeightfvARB != 0 )	++localInitializedProcCount;

		glWeightivARB = (PFNGLWEIGHTIVARBPROC) getExtensionPtr( "glWeightivARB" );
		if ( glWeightivARB != 0 )	++localInitializedProcCount;

		glWeightsvARB = (PFNGLWEIGHTSVARBPROC) getExtensionPtr( "glWeightsvARB" );
		if ( glWeightsvARB != 0 )	++localInitializedProcCount;

		glWeightubvARB = (PFNGLWEIGHTUBVARBPROC) getExtensionPtr( "glWeightubvARB" );
		if ( glWeightubvARB != 0 )	++localInitializedProcCount;

		glWeightuivARB = (PFNGLWEIGHTUIVARBPROC) getExtensionPtr( "glWeightuivARB" );
		if ( glWeightuivARB != 0 )	++localInitializedProcCount;

		glWeightusvARB = (PFNGLWEIGHTUSVARBPROC) getExtensionPtr( "glWeightusvARB" );
		if ( glWeightusvARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_blend )

	if ( isGL_ARB_vertex_blend )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_blend                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_blend                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_blend") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_blend                               : not detected." );
	}


	isGL_ARB_vertex_buffer_object = isExtensionSupported("GL_ARB_vertex_buffer_object");

	localSupportedProcCount		= 11;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_buffer_object ) // || isSEDEnable()
	{
		glBindBufferARB = (PFNGLBINDBUFFERARBPROC) getExtensionPtr( "glBindBufferARB" );
		if ( glBindBufferARB != 0 )	++localInitializedProcCount;

		glBufferDataARB = (PFNGLBUFFERDATAARBPROC) getExtensionPtr( "glBufferDataARB" );
		if ( glBufferDataARB != 0 )	++localInitializedProcCount;

		glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC) getExtensionPtr( "glBufferSubDataARB" );
		if ( glBufferSubDataARB != 0 )	++localInitializedProcCount;

		glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) getExtensionPtr( "glDeleteBuffersARB" );
		if ( glDeleteBuffersARB != 0 )	++localInitializedProcCount;

		glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) getExtensionPtr( "glGenBuffersARB" );
		if ( glGenBuffersARB != 0 )	++localInitializedProcCount;

		glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC) getExtensionPtr( "glGetBufferParameterivARB" );
		if ( glGetBufferParameterivARB != 0 )	++localInitializedProcCount;

		glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC) getExtensionPtr( "glGetBufferPointervARB" );
		if ( glGetBufferPointervARB != 0 )	++localInitializedProcCount;

		glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC) getExtensionPtr( "glGetBufferSubDataARB" );
		if ( glGetBufferSubDataARB != 0 )	++localInitializedProcCount;

		glIsBufferARB = (PFNGLISBUFFERARBPROC) getExtensionPtr( "glIsBufferARB" );
		if ( glIsBufferARB != 0 )	++localInitializedProcCount;

		glMapBufferARB = (PFNGLMAPBUFFERARBPROC) getExtensionPtr( "glMapBufferARB" );
		if ( glMapBufferARB != 0 )	++localInitializedProcCount;

		glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC) getExtensionPtr( "glUnmapBufferARB" );
		if ( glUnmapBufferARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_buffer_object )

	if ( isGL_ARB_vertex_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_buffer_object                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_buffer_object                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_buffer_object                       : not detected." );
	}


	isGL_ARB_vertex_program = isExtensionSupported("GL_ARB_vertex_program");

	localSupportedProcCount		= 62;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_program ) // || isSEDEnable()
	{
		glBindProgramARB = (PFNGLBINDPROGRAMARBPROC) getExtensionPtr( "glBindProgramARB" );
		if ( glBindProgramARB != 0 )	++localInitializedProcCount;

		glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) getExtensionPtr( "glDeleteProgramsARB" );
		if ( glDeleteProgramsARB != 0 )	++localInitializedProcCount;

		glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) getExtensionPtr( "glDisableVertexAttribArrayARB" );
		if ( glDisableVertexAttribArrayARB != 0 )	++localInitializedProcCount;

		glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) getExtensionPtr( "glEnableVertexAttribArrayARB" );
		if ( glEnableVertexAttribArrayARB != 0 )	++localInitializedProcCount;

		glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) getExtensionPtr( "glGenProgramsARB" );
		if ( glGenProgramsARB != 0 )	++localInitializedProcCount;

		glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) getExtensionPtr( "glGetProgramEnvParameterdvARB" );
		if ( glGetProgramEnvParameterdvARB != 0 )	++localInitializedProcCount;

		glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) getExtensionPtr( "glGetProgramEnvParameterfvARB" );
		if ( glGetProgramEnvParameterfvARB != 0 )	++localInitializedProcCount;

		glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) getExtensionPtr( "glGetProgramLocalParameterdvARB" );
		if ( glGetProgramLocalParameterdvARB != 0 )	++localInitializedProcCount;

		glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) getExtensionPtr( "glGetProgramLocalParameterfvARB" );
		if ( glGetProgramLocalParameterfvARB != 0 )	++localInitializedProcCount;

		glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC) getExtensionPtr( "glGetProgramStringARB" );
		if ( glGetProgramStringARB != 0 )	++localInitializedProcCount;

		glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) getExtensionPtr( "glGetProgramivARB" );
		if ( glGetProgramivARB != 0 )	++localInitializedProcCount;

		glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) getExtensionPtr( "glGetVertexAttribPointervARB" );
		if ( glGetVertexAttribPointervARB != 0 )	++localInitializedProcCount;

		glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) getExtensionPtr( "glGetVertexAttribdvARB" );
		if ( glGetVertexAttribdvARB != 0 )	++localInitializedProcCount;

		glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) getExtensionPtr( "glGetVertexAttribfvARB" );
		if ( glGetVertexAttribfvARB != 0 )	++localInitializedProcCount;

		glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) getExtensionPtr( "glGetVertexAttribivARB" );
		if ( glGetVertexAttribivARB != 0 )	++localInitializedProcCount;

		glIsProgramARB = (PFNGLISPROGRAMARBPROC) getExtensionPtr( "glIsProgramARB" );
		if ( glIsProgramARB != 0 )	++localInitializedProcCount;

		glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC) getExtensionPtr( "glProgramEnvParameter4dARB" );
		if ( glProgramEnvParameter4dARB != 0 )	++localInitializedProcCount;

		glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC) getExtensionPtr( "glProgramEnvParameter4dvARB" );
		if ( glProgramEnvParameter4dvARB != 0 )	++localInitializedProcCount;

		glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC) getExtensionPtr( "glProgramEnvParameter4fARB" );
		if ( glProgramEnvParameter4fARB != 0 )	++localInitializedProcCount;

		glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC) getExtensionPtr( "glProgramEnvParameter4fvARB" );
		if ( glProgramEnvParameter4fvARB != 0 )	++localInitializedProcCount;

		glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC) getExtensionPtr( "glProgramLocalParameter4dARB" );
		if ( glProgramLocalParameter4dARB != 0 )	++localInitializedProcCount;

		glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) getExtensionPtr( "glProgramLocalParameter4dvARB" );
		if ( glProgramLocalParameter4dvARB != 0 )	++localInitializedProcCount;

		glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC) getExtensionPtr( "glProgramLocalParameter4fARB" );
		if ( glProgramLocalParameter4fARB != 0 )	++localInitializedProcCount;

		glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) getExtensionPtr( "glProgramLocalParameter4fvARB" );
		if ( glProgramLocalParameter4fvARB != 0 )	++localInitializedProcCount;

		glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) getExtensionPtr( "glProgramStringARB" );
		if ( glProgramStringARB != 0 )	++localInitializedProcCount;

		glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC) getExtensionPtr( "glVertexAttrib1dARB" );
		if ( glVertexAttrib1dARB != 0 )	++localInitializedProcCount;

		glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) getExtensionPtr( "glVertexAttrib1dvARB" );
		if ( glVertexAttrib1dvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC) getExtensionPtr( "glVertexAttrib1fARB" );
		if ( glVertexAttrib1fARB != 0 )	++localInitializedProcCount;

		glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) getExtensionPtr( "glVertexAttrib1fvARB" );
		if ( glVertexAttrib1fvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC) getExtensionPtr( "glVertexAttrib1sARB" );
		if ( glVertexAttrib1sARB != 0 )	++localInitializedProcCount;

		glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) getExtensionPtr( "glVertexAttrib1svARB" );
		if ( glVertexAttrib1svARB != 0 )	++localInitializedProcCount;

		glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC) getExtensionPtr( "glVertexAttrib2dARB" );
		if ( glVertexAttrib2dARB != 0 )	++localInitializedProcCount;

		glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC) getExtensionPtr( "glVertexAttrib2dvARB" );
		if ( glVertexAttrib2dvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC) getExtensionPtr( "glVertexAttrib2fARB" );
		if ( glVertexAttrib2fARB != 0 )	++localInitializedProcCount;

		glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC) getExtensionPtr( "glVertexAttrib2fvARB" );
		if ( glVertexAttrib2fvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC) getExtensionPtr( "glVertexAttrib2sARB" );
		if ( glVertexAttrib2sARB != 0 )	++localInitializedProcCount;

		glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC) getExtensionPtr( "glVertexAttrib2svARB" );
		if ( glVertexAttrib2svARB != 0 )	++localInitializedProcCount;

		glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC) getExtensionPtr( "glVertexAttrib3dARB" );
		if ( glVertexAttrib3dARB != 0 )	++localInitializedProcCount;

		glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC) getExtensionPtr( "glVertexAttrib3dvARB" );
		if ( glVertexAttrib3dvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC) getExtensionPtr( "glVertexAttrib3fARB" );
		if ( glVertexAttrib3fARB != 0 )	++localInitializedProcCount;

		glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC) getExtensionPtr( "glVertexAttrib3fvARB" );
		if ( glVertexAttrib3fvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC) getExtensionPtr( "glVertexAttrib3sARB" );
		if ( glVertexAttrib3sARB != 0 )	++localInitializedProcCount;

		glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC) getExtensionPtr( "glVertexAttrib3svARB" );
		if ( glVertexAttrib3svARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC) getExtensionPtr( "glVertexAttrib4NbvARB" );
		if ( glVertexAttrib4NbvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC) getExtensionPtr( "glVertexAttrib4NivARB" );
		if ( glVertexAttrib4NivARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) getExtensionPtr( "glVertexAttrib4NsvARB" );
		if ( glVertexAttrib4NsvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC) getExtensionPtr( "glVertexAttrib4NubARB" );
		if ( glVertexAttrib4NubARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) getExtensionPtr( "glVertexAttrib4NubvARB" );
		if ( glVertexAttrib4NubvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) getExtensionPtr( "glVertexAttrib4NuivARB" );
		if ( glVertexAttrib4NuivARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) getExtensionPtr( "glVertexAttrib4NusvARB" );
		if ( glVertexAttrib4NusvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC) getExtensionPtr( "glVertexAttrib4bvARB" );
		if ( glVertexAttrib4bvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC) getExtensionPtr( "glVertexAttrib4dARB" );
		if ( glVertexAttrib4dARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC) getExtensionPtr( "glVertexAttrib4dvARB" );
		if ( glVertexAttrib4dvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC) getExtensionPtr( "glVertexAttrib4fARB" );
		if ( glVertexAttrib4fARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC) getExtensionPtr( "glVertexAttrib4fvARB" );
		if ( glVertexAttrib4fvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) getExtensionPtr( "glVertexAttrib4ivARB" );
		if ( glVertexAttrib4ivARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC) getExtensionPtr( "glVertexAttrib4sARB" );
		if ( glVertexAttrib4sARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC) getExtensionPtr( "glVertexAttrib4svARB" );
		if ( glVertexAttrib4svARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC) getExtensionPtr( "glVertexAttrib4ubvARB" );
		if ( glVertexAttrib4ubvARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC) getExtensionPtr( "glVertexAttrib4uivARB" );
		if ( glVertexAttrib4uivARB != 0 )	++localInitializedProcCount;

		glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC) getExtensionPtr( "glVertexAttrib4usvARB" );
		if ( glVertexAttrib4usvARB != 0 )	++localInitializedProcCount;

		glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) getExtensionPtr( "glVertexAttribPointerARB" );
		if ( glVertexAttribPointerARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_program )

	if ( isGL_ARB_vertex_program )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_program                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_program                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_program") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_program                             : not detected." );
	}


	isGL_ARB_vertex_shader = isExtensionSupported("GL_ARB_vertex_shader");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_shader ) // || isSEDEnable()
	{
		glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC) getExtensionPtr( "glBindAttribLocationARB" );
		if ( glBindAttribLocationARB != 0 )	++localInitializedProcCount;

		glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC) getExtensionPtr( "glGetActiveAttribARB" );
		if ( glGetActiveAttribARB != 0 )	++localInitializedProcCount;

		glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC) getExtensionPtr( "glGetAttribLocationARB" );
		if ( glGetAttribLocationARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_shader )

	if ( isGL_ARB_vertex_shader )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_shader                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_shader                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_shader                              : not detected." );
	}


	isGL_ARB_vertex_type_2_10_10_10_rev = isExtensionSupported("GL_ARB_vertex_type_2_10_10_10_rev");

	localSupportedProcCount		= 38;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_vertex_type_2_10_10_10_rev ) // || isSEDEnable()
	{
		glColorP3ui = (PFNGLCOLORP3UIPROC) getExtensionPtr( "glColorP3ui" );
		if ( glColorP3ui != 0 )	++localInitializedProcCount;

		glColorP3uiv = (PFNGLCOLORP3UIVPROC) getExtensionPtr( "glColorP3uiv" );
		if ( glColorP3uiv != 0 )	++localInitializedProcCount;

		glColorP4ui = (PFNGLCOLORP4UIPROC) getExtensionPtr( "glColorP4ui" );
		if ( glColorP4ui != 0 )	++localInitializedProcCount;

		glColorP4uiv = (PFNGLCOLORP4UIVPROC) getExtensionPtr( "glColorP4uiv" );
		if ( glColorP4uiv != 0 )	++localInitializedProcCount;

		glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC) getExtensionPtr( "glMultiTexCoordP1ui" );
		if ( glMultiTexCoordP1ui != 0 )	++localInitializedProcCount;

		glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC) getExtensionPtr( "glMultiTexCoordP1uiv" );
		if ( glMultiTexCoordP1uiv != 0 )	++localInitializedProcCount;

		glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC) getExtensionPtr( "glMultiTexCoordP2ui" );
		if ( glMultiTexCoordP2ui != 0 )	++localInitializedProcCount;

		glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC) getExtensionPtr( "glMultiTexCoordP2uiv" );
		if ( glMultiTexCoordP2uiv != 0 )	++localInitializedProcCount;

		glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC) getExtensionPtr( "glMultiTexCoordP3ui" );
		if ( glMultiTexCoordP3ui != 0 )	++localInitializedProcCount;

		glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC) getExtensionPtr( "glMultiTexCoordP3uiv" );
		if ( glMultiTexCoordP3uiv != 0 )	++localInitializedProcCount;

		glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC) getExtensionPtr( "glMultiTexCoordP4ui" );
		if ( glMultiTexCoordP4ui != 0 )	++localInitializedProcCount;

		glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC) getExtensionPtr( "glMultiTexCoordP4uiv" );
		if ( glMultiTexCoordP4uiv != 0 )	++localInitializedProcCount;

		glNormalP3ui = (PFNGLNORMALP3UIPROC) getExtensionPtr( "glNormalP3ui" );
		if ( glNormalP3ui != 0 )	++localInitializedProcCount;

		glNormalP3uiv = (PFNGLNORMALP3UIVPROC) getExtensionPtr( "glNormalP3uiv" );
		if ( glNormalP3uiv != 0 )	++localInitializedProcCount;

		glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC) getExtensionPtr( "glSecondaryColorP3ui" );
		if ( glSecondaryColorP3ui != 0 )	++localInitializedProcCount;

		glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC) getExtensionPtr( "glSecondaryColorP3uiv" );
		if ( glSecondaryColorP3uiv != 0 )	++localInitializedProcCount;

		glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC) getExtensionPtr( "glTexCoordP1ui" );
		if ( glTexCoordP1ui != 0 )	++localInitializedProcCount;

		glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC) getExtensionPtr( "glTexCoordP1uiv" );
		if ( glTexCoordP1uiv != 0 )	++localInitializedProcCount;

		glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC) getExtensionPtr( "glTexCoordP2ui" );
		if ( glTexCoordP2ui != 0 )	++localInitializedProcCount;

		glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC) getExtensionPtr( "glTexCoordP2uiv" );
		if ( glTexCoordP2uiv != 0 )	++localInitializedProcCount;

		glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC) getExtensionPtr( "glTexCoordP3ui" );
		if ( glTexCoordP3ui != 0 )	++localInitializedProcCount;

		glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC) getExtensionPtr( "glTexCoordP3uiv" );
		if ( glTexCoordP3uiv != 0 )	++localInitializedProcCount;

		glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC) getExtensionPtr( "glTexCoordP4ui" );
		if ( glTexCoordP4ui != 0 )	++localInitializedProcCount;

		glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC) getExtensionPtr( "glTexCoordP4uiv" );
		if ( glTexCoordP4uiv != 0 )	++localInitializedProcCount;

		glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC) getExtensionPtr( "glVertexAttribP1ui" );
		if ( glVertexAttribP1ui != 0 )	++localInitializedProcCount;

		glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC) getExtensionPtr( "glVertexAttribP1uiv" );
		if ( glVertexAttribP1uiv != 0 )	++localInitializedProcCount;

		glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC) getExtensionPtr( "glVertexAttribP2ui" );
		if ( glVertexAttribP2ui != 0 )	++localInitializedProcCount;

		glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC) getExtensionPtr( "glVertexAttribP2uiv" );
		if ( glVertexAttribP2uiv != 0 )	++localInitializedProcCount;

		glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC) getExtensionPtr( "glVertexAttribP3ui" );
		if ( glVertexAttribP3ui != 0 )	++localInitializedProcCount;

		glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC) getExtensionPtr( "glVertexAttribP3uiv" );
		if ( glVertexAttribP3uiv != 0 )	++localInitializedProcCount;

		glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC) getExtensionPtr( "glVertexAttribP4ui" );
		if ( glVertexAttribP4ui != 0 )	++localInitializedProcCount;

		glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC) getExtensionPtr( "glVertexAttribP4uiv" );
		if ( glVertexAttribP4uiv != 0 )	++localInitializedProcCount;

		glVertexP2ui = (PFNGLVERTEXP2UIPROC) getExtensionPtr( "glVertexP2ui" );
		if ( glVertexP2ui != 0 )	++localInitializedProcCount;

		glVertexP2uiv = (PFNGLVERTEXP2UIVPROC) getExtensionPtr( "glVertexP2uiv" );
		if ( glVertexP2uiv != 0 )	++localInitializedProcCount;

		glVertexP3ui = (PFNGLVERTEXP3UIPROC) getExtensionPtr( "glVertexP3ui" );
		if ( glVertexP3ui != 0 )	++localInitializedProcCount;

		glVertexP3uiv = (PFNGLVERTEXP3UIVPROC) getExtensionPtr( "glVertexP3uiv" );
		if ( glVertexP3uiv != 0 )	++localInitializedProcCount;

		glVertexP4ui = (PFNGLVERTEXP4UIPROC) getExtensionPtr( "glVertexP4ui" );
		if ( glVertexP4ui != 0 )	++localInitializedProcCount;

		glVertexP4uiv = (PFNGLVERTEXP4UIVPROC) getExtensionPtr( "glVertexP4uiv" );
		if ( glVertexP4uiv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_vertex_type_2_10_10_10_rev )

	if ( isGL_ARB_vertex_type_2_10_10_10_rev )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_vertex_type_2_10_10_10_rev                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_vertex_type_2_10_10_10_rev                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_vertex_type_2_10_10_10_rev") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_vertex_type_2_10_10_10_rev                 : not detected." );
	}


	isGL_ARB_viewport_array = isExtensionSupported("GL_ARB_viewport_array");

	localSupportedProcCount		= 10;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_viewport_array ) // || isSEDEnable()
	{
		glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC) getExtensionPtr( "glDepthRangeArrayv" );
		if ( glDepthRangeArrayv != 0 )	++localInitializedProcCount;

		glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC) getExtensionPtr( "glDepthRangeIndexed" );
		if ( glDepthRangeIndexed != 0 )	++localInitializedProcCount;

		glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC) getExtensionPtr( "glGetDoublei_v" );
		if ( glGetDoublei_v != 0 )	++localInitializedProcCount;

		glGetFloati_v = (PFNGLGETFLOATI_VPROC) getExtensionPtr( "glGetFloati_v" );
		if ( glGetFloati_v != 0 )	++localInitializedProcCount;

		glScissorArrayv = (PFNGLSCISSORARRAYVPROC) getExtensionPtr( "glScissorArrayv" );
		if ( glScissorArrayv != 0 )	++localInitializedProcCount;

		glScissorIndexed = (PFNGLSCISSORINDEXEDPROC) getExtensionPtr( "glScissorIndexed" );
		if ( glScissorIndexed != 0 )	++localInitializedProcCount;

		glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC) getExtensionPtr( "glScissorIndexedv" );
		if ( glScissorIndexedv != 0 )	++localInitializedProcCount;

		glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC) getExtensionPtr( "glViewportArrayv" );
		if ( glViewportArrayv != 0 )	++localInitializedProcCount;

		glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC) getExtensionPtr( "glViewportIndexedf" );
		if ( glViewportIndexedf != 0 )	++localInitializedProcCount;

		glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC) getExtensionPtr( "glViewportIndexedfv" );
		if ( glViewportIndexedfv != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_viewport_array )

	if ( isGL_ARB_viewport_array )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_viewport_array                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_viewport_array                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_viewport_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_viewport_array                             : not detected." );
	}


	isGL_ARB_window_pos = isExtensionSupported("GL_ARB_window_pos");

	localSupportedProcCount		= 16;
	localInitializedProcCount	= 0;

	if ( isGL_ARB_window_pos ) // || isSEDEnable()
	{
		glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC) getExtensionPtr( "glWindowPos2dARB" );
		if ( glWindowPos2dARB != 0 )	++localInitializedProcCount;

		glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC) getExtensionPtr( "glWindowPos2dvARB" );
		if ( glWindowPos2dvARB != 0 )	++localInitializedProcCount;

		glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC) getExtensionPtr( "glWindowPos2fARB" );
		if ( glWindowPos2fARB != 0 )	++localInitializedProcCount;

		glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC) getExtensionPtr( "glWindowPos2fvARB" );
		if ( glWindowPos2fvARB != 0 )	++localInitializedProcCount;

		glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC) getExtensionPtr( "glWindowPos2iARB" );
		if ( glWindowPos2iARB != 0 )	++localInitializedProcCount;

		glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC) getExtensionPtr( "glWindowPos2ivARB" );
		if ( glWindowPos2ivARB != 0 )	++localInitializedProcCount;

		glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC) getExtensionPtr( "glWindowPos2sARB" );
		if ( glWindowPos2sARB != 0 )	++localInitializedProcCount;

		glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC) getExtensionPtr( "glWindowPos2svARB" );
		if ( glWindowPos2svARB != 0 )	++localInitializedProcCount;

		glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC) getExtensionPtr( "glWindowPos3dARB" );
		if ( glWindowPos3dARB != 0 )	++localInitializedProcCount;

		glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC) getExtensionPtr( "glWindowPos3dvARB" );
		if ( glWindowPos3dvARB != 0 )	++localInitializedProcCount;

		glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC) getExtensionPtr( "glWindowPos3fARB" );
		if ( glWindowPos3fARB != 0 )	++localInitializedProcCount;

		glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC) getExtensionPtr( "glWindowPos3fvARB" );
		if ( glWindowPos3fvARB != 0 )	++localInitializedProcCount;

		glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC) getExtensionPtr( "glWindowPos3iARB" );
		if ( glWindowPos3iARB != 0 )	++localInitializedProcCount;

		glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC) getExtensionPtr( "glWindowPos3ivARB" );
		if ( glWindowPos3ivARB != 0 )	++localInitializedProcCount;

		glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC) getExtensionPtr( "glWindowPos3sARB" );
		if ( glWindowPos3sARB != 0 )	++localInitializedProcCount;

		glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC) getExtensionPtr( "glWindowPos3svARB" );
		if ( glWindowPos3svARB != 0 )	++localInitializedProcCount;

	} // if ( isGL_ARB_window_pos )

	if ( isGL_ARB_window_pos )
	{
		std::stringstream strStream;
		strStream << "GL_ARB_window_pos                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ARB_window_pos                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ARB_window_pos") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ARB_window_pos                                 : not detected." );
	}


} // initializeGL_ARB_window_pos()


void OpenGLExtensionsGen::initializeGL_ATI()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_ATI_draw_buffers = isExtensionSupported("GL_ATI_draw_buffers");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_draw_buffers ) // || isSEDEnable()
	{
		glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC) getExtensionPtr( "glDrawBuffersATI" );
		if ( glDrawBuffersATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_draw_buffers )

	if ( isGL_ATI_draw_buffers )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_draw_buffers                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_draw_buffers                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_draw_buffers") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_draw_buffers                               : not detected." );
	}


	isGL_ATI_element_array = isExtensionSupported("GL_ATI_element_array");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_element_array ) // || isSEDEnable()
	{
		glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC) getExtensionPtr( "glDrawElementArrayATI" );
		if ( glDrawElementArrayATI != 0 )	++localInitializedProcCount;

		glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC) getExtensionPtr( "glDrawRangeElementArrayATI" );
		if ( glDrawRangeElementArrayATI != 0 )	++localInitializedProcCount;

		glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC) getExtensionPtr( "glElementPointerATI" );
		if ( glElementPointerATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_element_array )

	if ( isGL_ATI_element_array )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_element_array                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_element_array                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_element_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_element_array                              : not detected." );
	}


	isGL_ATI_envmap_bumpmap = isExtensionSupported("GL_ATI_envmap_bumpmap");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_envmap_bumpmap ) // || isSEDEnable()
	{
		glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC) getExtensionPtr( "glGetTexBumpParameterfvATI" );
		if ( glGetTexBumpParameterfvATI != 0 )	++localInitializedProcCount;

		glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC) getExtensionPtr( "glGetTexBumpParameterivATI" );
		if ( glGetTexBumpParameterivATI != 0 )	++localInitializedProcCount;

		glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC) getExtensionPtr( "glTexBumpParameterfvATI" );
		if ( glTexBumpParameterfvATI != 0 )	++localInitializedProcCount;

		glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC) getExtensionPtr( "glTexBumpParameterivATI" );
		if ( glTexBumpParameterivATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_envmap_bumpmap )

	if ( isGL_ATI_envmap_bumpmap )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_envmap_bumpmap                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_envmap_bumpmap                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_envmap_bumpmap") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_envmap_bumpmap                             : not detected." );
	}


	isGL_ATI_fragment_shader = isExtensionSupported("GL_ATI_fragment_shader");

	localSupportedProcCount		= 14;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_fragment_shader ) // || isSEDEnable()
	{
		glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC) getExtensionPtr( "glAlphaFragmentOp1ATI" );
		if ( glAlphaFragmentOp1ATI != 0 )	++localInitializedProcCount;

		glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC) getExtensionPtr( "glAlphaFragmentOp2ATI" );
		if ( glAlphaFragmentOp2ATI != 0 )	++localInitializedProcCount;

		glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC) getExtensionPtr( "glAlphaFragmentOp3ATI" );
		if ( glAlphaFragmentOp3ATI != 0 )	++localInitializedProcCount;

		glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC) getExtensionPtr( "glBeginFragmentShaderATI" );
		if ( glBeginFragmentShaderATI != 0 )	++localInitializedProcCount;

		glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC) getExtensionPtr( "glBindFragmentShaderATI" );
		if ( glBindFragmentShaderATI != 0 )	++localInitializedProcCount;

		glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC) getExtensionPtr( "glColorFragmentOp1ATI" );
		if ( glColorFragmentOp1ATI != 0 )	++localInitializedProcCount;

		glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC) getExtensionPtr( "glColorFragmentOp2ATI" );
		if ( glColorFragmentOp2ATI != 0 )	++localInitializedProcCount;

		glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC) getExtensionPtr( "glColorFragmentOp3ATI" );
		if ( glColorFragmentOp3ATI != 0 )	++localInitializedProcCount;

		glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC) getExtensionPtr( "glDeleteFragmentShaderATI" );
		if ( glDeleteFragmentShaderATI != 0 )	++localInitializedProcCount;

		glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC) getExtensionPtr( "glEndFragmentShaderATI" );
		if ( glEndFragmentShaderATI != 0 )	++localInitializedProcCount;

		glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC) getExtensionPtr( "glGenFragmentShadersATI" );
		if ( glGenFragmentShadersATI != 0 )	++localInitializedProcCount;

		glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC) getExtensionPtr( "glPassTexCoordATI" );
		if ( glPassTexCoordATI != 0 )	++localInitializedProcCount;

		glSampleMapATI = (PFNGLSAMPLEMAPATIPROC) getExtensionPtr( "glSampleMapATI" );
		if ( glSampleMapATI != 0 )	++localInitializedProcCount;

		glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) getExtensionPtr( "glSetFragmentShaderConstantATI" );
		if ( glSetFragmentShaderConstantATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_fragment_shader )

	if ( isGL_ATI_fragment_shader )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_fragment_shader                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_fragment_shader                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_fragment_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_fragment_shader                            : not detected." );
	}


	isGL_ATI_map_object_buffer = isExtensionSupported("GL_ATI_map_object_buffer");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_map_object_buffer ) // || isSEDEnable()
	{
		glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC) getExtensionPtr( "glMapObjectBufferATI" );
		if ( glMapObjectBufferATI != 0 )	++localInitializedProcCount;

		glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC) getExtensionPtr( "glUnmapObjectBufferATI" );
		if ( glUnmapObjectBufferATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_map_object_buffer )

	if ( isGL_ATI_map_object_buffer )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_map_object_buffer                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_map_object_buffer                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_map_object_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_map_object_buffer                          : not detected." );
	}


	isGL_ATI_meminfo = isExtensionSupported("GL_ATI_meminfo");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_meminfo )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_meminfo                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_meminfo                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_meminfo") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_meminfo                                    : not detected." );
	}


	isGL_ATI_pixel_format_float = isExtensionSupported("GL_ATI_pixel_format_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_pixel_format_float )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_pixel_format_float                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_pixel_format_float                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_pixel_format_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_pixel_format_float                         : not detected." );
	}


	isGL_ATI_pn_triangles = isExtensionSupported("GL_ATI_pn_triangles");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_pn_triangles ) // || isSEDEnable()
	{
		glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC) getExtensionPtr( "glPNTrianglesfATI" );
		if ( glPNTrianglesfATI != 0 )	++localInitializedProcCount;

		glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC) getExtensionPtr( "glPNTrianglesiATI" );
		if ( glPNTrianglesiATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_pn_triangles )

	if ( isGL_ATI_pn_triangles )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_pn_triangles                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_pn_triangles                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_pn_triangles") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_pn_triangles                               : not detected." );
	}


	isGL_ATI_separate_stencil = isExtensionSupported("GL_ATI_separate_stencil");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_separate_stencil ) // || isSEDEnable()
	{
		glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) getExtensionPtr( "glStencilFuncSeparateATI" );
		if ( glStencilFuncSeparateATI != 0 )	++localInitializedProcCount;

		glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC) getExtensionPtr( "glStencilOpSeparateATI" );
		if ( glStencilOpSeparateATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_separate_stencil )

	if ( isGL_ATI_separate_stencil )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_separate_stencil                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_separate_stencil                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_separate_stencil") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_separate_stencil                           : not detected." );
	}


	isGL_ATI_text_fragment_shader = isExtensionSupported("GL_ATI_text_fragment_shader");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_text_fragment_shader )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_text_fragment_shader                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_text_fragment_shader                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_text_fragment_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_text_fragment_shader                       : not detected." );
	}


	isGL_ATI_texture_env_combine3 = isExtensionSupported("GL_ATI_texture_env_combine3");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_texture_env_combine3 )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_texture_env_combine3                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_texture_env_combine3                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_texture_env_combine3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_texture_env_combine3                       : not detected." );
	}


	isGL_ATI_texture_float = isExtensionSupported("GL_ATI_texture_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_texture_float )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_texture_float                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_texture_float                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_texture_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_texture_float                              : not detected." );
	}


	isGL_ATI_texture_mirror_once = isExtensionSupported("GL_ATI_texture_mirror_once");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_texture_mirror_once )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_texture_mirror_once                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_texture_mirror_once                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_texture_mirror_once") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_texture_mirror_once                        : not detected." );
	}


	isGL_ATI_vertex_array_object = isExtensionSupported("GL_ATI_vertex_array_object");

	localSupportedProcCount		= 12;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_vertex_array_object ) // || isSEDEnable()
	{
		glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC) getExtensionPtr( "glArrayObjectATI" );
		if ( glArrayObjectATI != 0 )	++localInitializedProcCount;

		glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC) getExtensionPtr( "glFreeObjectBufferATI" );
		if ( glFreeObjectBufferATI != 0 )	++localInitializedProcCount;

		glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC) getExtensionPtr( "glGetArrayObjectfvATI" );
		if ( glGetArrayObjectfvATI != 0 )	++localInitializedProcCount;

		glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC) getExtensionPtr( "glGetArrayObjectivATI" );
		if ( glGetArrayObjectivATI != 0 )	++localInitializedProcCount;

		glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC) getExtensionPtr( "glGetObjectBufferfvATI" );
		if ( glGetObjectBufferfvATI != 0 )	++localInitializedProcCount;

		glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC) getExtensionPtr( "glGetObjectBufferivATI" );
		if ( glGetObjectBufferivATI != 0 )	++localInitializedProcCount;

		glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC) getExtensionPtr( "glGetVariantArrayObjectfvATI" );
		if ( glGetVariantArrayObjectfvATI != 0 )	++localInitializedProcCount;

		glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC) getExtensionPtr( "glGetVariantArrayObjectivATI" );
		if ( glGetVariantArrayObjectivATI != 0 )	++localInitializedProcCount;

		glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC) getExtensionPtr( "glIsObjectBufferATI" );
		if ( glIsObjectBufferATI != 0 )	++localInitializedProcCount;

		glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC) getExtensionPtr( "glNewObjectBufferATI" );
		if ( glNewObjectBufferATI != 0 )	++localInitializedProcCount;

		glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC) getExtensionPtr( "glUpdateObjectBufferATI" );
		if ( glUpdateObjectBufferATI != 0 )	++localInitializedProcCount;

		glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC) getExtensionPtr( "glVariantArrayObjectATI" );
		if ( glVariantArrayObjectATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_vertex_array_object )

	if ( isGL_ATI_vertex_array_object )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_vertex_array_object                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_vertex_array_object                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_vertex_array_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_vertex_array_object                        : not detected." );
	}


	isGL_ATI_vertex_attrib_array_object = isExtensionSupported("GL_ATI_vertex_attrib_array_object");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_vertex_attrib_array_object ) // || isSEDEnable()
	{
		glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) getExtensionPtr( "glGetVertexAttribArrayObjectfvATI" );
		if ( glGetVertexAttribArrayObjectfvATI != 0 )	++localInitializedProcCount;

		glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) getExtensionPtr( "glGetVertexAttribArrayObjectivATI" );
		if ( glGetVertexAttribArrayObjectivATI != 0 )	++localInitializedProcCount;

		glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) getExtensionPtr( "glVertexAttribArrayObjectATI" );
		if ( glVertexAttribArrayObjectATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_vertex_attrib_array_object )

	if ( isGL_ATI_vertex_attrib_array_object )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_vertex_attrib_array_object                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_vertex_attrib_array_object                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_vertex_attrib_array_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_vertex_attrib_array_object                 : not detected." );
	}


	isGL_ATI_vertex_streams = isExtensionSupported("GL_ATI_vertex_streams");

	localSupportedProcCount		= 45;
	localInitializedProcCount	= 0;

	if ( isGL_ATI_vertex_streams ) // || isSEDEnable()
	{
		glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) getExtensionPtr( "glClientActiveVertexStreamATI" );
		if ( glClientActiveVertexStreamATI != 0 )	++localInitializedProcCount;

		glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC) getExtensionPtr( "glNormalStream3bATI" );
		if ( glNormalStream3bATI != 0 )	++localInitializedProcCount;

		glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC) getExtensionPtr( "glNormalStream3bvATI" );
		if ( glNormalStream3bvATI != 0 )	++localInitializedProcCount;

		glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC) getExtensionPtr( "glNormalStream3dATI" );
		if ( glNormalStream3dATI != 0 )	++localInitializedProcCount;

		glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC) getExtensionPtr( "glNormalStream3dvATI" );
		if ( glNormalStream3dvATI != 0 )	++localInitializedProcCount;

		glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC) getExtensionPtr( "glNormalStream3fATI" );
		if ( glNormalStream3fATI != 0 )	++localInitializedProcCount;

		glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC) getExtensionPtr( "glNormalStream3fvATI" );
		if ( glNormalStream3fvATI != 0 )	++localInitializedProcCount;

		glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC) getExtensionPtr( "glNormalStream3iATI" );
		if ( glNormalStream3iATI != 0 )	++localInitializedProcCount;

		glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC) getExtensionPtr( "glNormalStream3ivATI" );
		if ( glNormalStream3ivATI != 0 )	++localInitializedProcCount;

		glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC) getExtensionPtr( "glNormalStream3sATI" );
		if ( glNormalStream3sATI != 0 )	++localInitializedProcCount;

		glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC) getExtensionPtr( "glNormalStream3svATI" );
		if ( glNormalStream3svATI != 0 )	++localInitializedProcCount;

		glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC) getExtensionPtr( "glVertexBlendEnvfATI" );
		if ( glVertexBlendEnvfATI != 0 )	++localInitializedProcCount;

		glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC) getExtensionPtr( "glVertexBlendEnviATI" );
		if ( glVertexBlendEnviATI != 0 )	++localInitializedProcCount;

		glVertexStream1dATI = (PFNGLVERTEXSTREAM1DATIPROC) getExtensionPtr( "glVertexStream1dATI" );
		if ( glVertexStream1dATI != 0 )	++localInitializedProcCount;

		glVertexStream1dvATI = (PFNGLVERTEXSTREAM1DVATIPROC) getExtensionPtr( "glVertexStream1dvATI" );
		if ( glVertexStream1dvATI != 0 )	++localInitializedProcCount;

		glVertexStream1fATI = (PFNGLVERTEXSTREAM1FATIPROC) getExtensionPtr( "glVertexStream1fATI" );
		if ( glVertexStream1fATI != 0 )	++localInitializedProcCount;

		glVertexStream1fvATI = (PFNGLVERTEXSTREAM1FVATIPROC) getExtensionPtr( "glVertexStream1fvATI" );
		if ( glVertexStream1fvATI != 0 )	++localInitializedProcCount;

		glVertexStream1iATI = (PFNGLVERTEXSTREAM1IATIPROC) getExtensionPtr( "glVertexStream1iATI" );
		if ( glVertexStream1iATI != 0 )	++localInitializedProcCount;

		glVertexStream1ivATI = (PFNGLVERTEXSTREAM1IVATIPROC) getExtensionPtr( "glVertexStream1ivATI" );
		if ( glVertexStream1ivATI != 0 )	++localInitializedProcCount;

		glVertexStream1sATI = (PFNGLVERTEXSTREAM1SATIPROC) getExtensionPtr( "glVertexStream1sATI" );
		if ( glVertexStream1sATI != 0 )	++localInitializedProcCount;

		glVertexStream1svATI = (PFNGLVERTEXSTREAM1SVATIPROC) getExtensionPtr( "glVertexStream1svATI" );
		if ( glVertexStream1svATI != 0 )	++localInitializedProcCount;

		glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC) getExtensionPtr( "glVertexStream2dATI" );
		if ( glVertexStream2dATI != 0 )	++localInitializedProcCount;

		glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC) getExtensionPtr( "glVertexStream2dvATI" );
		if ( glVertexStream2dvATI != 0 )	++localInitializedProcCount;

		glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC) getExtensionPtr( "glVertexStream2fATI" );
		if ( glVertexStream2fATI != 0 )	++localInitializedProcCount;

		glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC) getExtensionPtr( "glVertexStream2fvATI" );
		if ( glVertexStream2fvATI != 0 )	++localInitializedProcCount;

		glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC) getExtensionPtr( "glVertexStream2iATI" );
		if ( glVertexStream2iATI != 0 )	++localInitializedProcCount;

		glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC) getExtensionPtr( "glVertexStream2ivATI" );
		if ( glVertexStream2ivATI != 0 )	++localInitializedProcCount;

		glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC) getExtensionPtr( "glVertexStream2sATI" );
		if ( glVertexStream2sATI != 0 )	++localInitializedProcCount;

		glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC) getExtensionPtr( "glVertexStream2svATI" );
		if ( glVertexStream2svATI != 0 )	++localInitializedProcCount;

		glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC) getExtensionPtr( "glVertexStream3dATI" );
		if ( glVertexStream3dATI != 0 )	++localInitializedProcCount;

		glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC) getExtensionPtr( "glVertexStream3dvATI" );
		if ( glVertexStream3dvATI != 0 )	++localInitializedProcCount;

		glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC) getExtensionPtr( "glVertexStream3fATI" );
		if ( glVertexStream3fATI != 0 )	++localInitializedProcCount;

		glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC) getExtensionPtr( "glVertexStream3fvATI" );
		if ( glVertexStream3fvATI != 0 )	++localInitializedProcCount;

		glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC) getExtensionPtr( "glVertexStream3iATI" );
		if ( glVertexStream3iATI != 0 )	++localInitializedProcCount;

		glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC) getExtensionPtr( "glVertexStream3ivATI" );
		if ( glVertexStream3ivATI != 0 )	++localInitializedProcCount;

		glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC) getExtensionPtr( "glVertexStream3sATI" );
		if ( glVertexStream3sATI != 0 )	++localInitializedProcCount;

		glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC) getExtensionPtr( "glVertexStream3svATI" );
		if ( glVertexStream3svATI != 0 )	++localInitializedProcCount;

		glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC) getExtensionPtr( "glVertexStream4dATI" );
		if ( glVertexStream4dATI != 0 )	++localInitializedProcCount;

		glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC) getExtensionPtr( "glVertexStream4dvATI" );
		if ( glVertexStream4dvATI != 0 )	++localInitializedProcCount;

		glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC) getExtensionPtr( "glVertexStream4fATI" );
		if ( glVertexStream4fATI != 0 )	++localInitializedProcCount;

		glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC) getExtensionPtr( "glVertexStream4fvATI" );
		if ( glVertexStream4fvATI != 0 )	++localInitializedProcCount;

		glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC) getExtensionPtr( "glVertexStream4iATI" );
		if ( glVertexStream4iATI != 0 )	++localInitializedProcCount;

		glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC) getExtensionPtr( "glVertexStream4ivATI" );
		if ( glVertexStream4ivATI != 0 )	++localInitializedProcCount;

		glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC) getExtensionPtr( "glVertexStream4sATI" );
		if ( glVertexStream4sATI != 0 )	++localInitializedProcCount;

		glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC) getExtensionPtr( "glVertexStream4svATI" );
		if ( glVertexStream4svATI != 0 )	++localInitializedProcCount;

	} // if ( isGL_ATI_vertex_streams )

	if ( isGL_ATI_vertex_streams )
	{
		std::stringstream strStream;
		strStream << "GL_ATI_vertex_streams                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_ATI_vertex_streams                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_ATI_vertex_streams") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_ATI_vertex_streams                             : not detected." );
	}


} // initializeGL_ATI_vertex_streams()


void OpenGLExtensionsGen::initializeGL_EXT()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_EXT_422_pixels = isExtensionSupported("GL_EXT_422_pixels");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_422_pixels )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_422_pixels                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_422_pixels                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_422_pixels") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_422_pixels                                 : not detected." );
	}


	isGL_EXT_abgr = isExtensionSupported("GL_EXT_abgr");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_abgr )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_abgr                                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_abgr                                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_abgr") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_abgr                                       : not detected." );
	}


	isGL_EXT_bgra = isExtensionSupported("GL_EXT_bgra");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_bgra )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_bgra                                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_bgra                                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_bgra") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_bgra                                       : not detected." );
	}


	isGL_EXT_bindable_uniform = isExtensionSupported("GL_EXT_bindable_uniform");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_bindable_uniform ) // || isSEDEnable()
	{
		glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC) getExtensionPtr( "glGetUniformBufferSizeEXT" );
		if ( glGetUniformBufferSizeEXT != 0 )	++localInitializedProcCount;

		glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC) getExtensionPtr( "glGetUniformOffsetEXT" );
		if ( glGetUniformOffsetEXT != 0 )	++localInitializedProcCount;

		glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC) getExtensionPtr( "glUniformBufferEXT" );
		if ( glUniformBufferEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_bindable_uniform )

	if ( isGL_EXT_bindable_uniform )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_bindable_uniform                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_bindable_uniform                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_bindable_uniform") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_bindable_uniform                           : not detected." );
	}


	isGL_EXT_blend_color = isExtensionSupported("GL_EXT_blend_color");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_blend_color ) // || isSEDEnable()
	{
		glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC) getExtensionPtr( "glBlendColorEXT" );
		if ( glBlendColorEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_blend_color )

	if ( isGL_EXT_blend_color )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_blend_color                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_blend_color                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_blend_color") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_blend_color                                : not detected." );
	}


	isGL_EXT_blend_equation_separate = isExtensionSupported("GL_EXT_blend_equation_separate");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_blend_equation_separate ) // || isSEDEnable()
	{
		glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC) getExtensionPtr( "glBlendEquationSeparateEXT" );
		if ( glBlendEquationSeparateEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_blend_equation_separate )

	if ( isGL_EXT_blend_equation_separate )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_blend_equation_separate                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_blend_equation_separate                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_blend_equation_separate") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_blend_equation_separate                    : not detected." );
	}


	isGL_EXT_blend_func_separate = isExtensionSupported("GL_EXT_blend_func_separate");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_blend_func_separate ) // || isSEDEnable()
	{
		glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC) getExtensionPtr( "glBlendFuncSeparateEXT" );
		if ( glBlendFuncSeparateEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_blend_func_separate )

	if ( isGL_EXT_blend_func_separate )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_blend_func_separate                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_blend_func_separate                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_blend_func_separate") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_blend_func_separate                        : not detected." );
	}


	isGL_EXT_blend_logic_op = isExtensionSupported("GL_EXT_blend_logic_op");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_blend_logic_op )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_blend_logic_op                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_blend_logic_op                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_blend_logic_op") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_blend_logic_op                             : not detected." );
	}


	isGL_EXT_blend_minmax = isExtensionSupported("GL_EXT_blend_minmax");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_blend_minmax ) // || isSEDEnable()
	{
		glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC) getExtensionPtr( "glBlendEquationEXT" );
		if ( glBlendEquationEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_blend_minmax )

	if ( isGL_EXT_blend_minmax )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_blend_minmax                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_blend_minmax                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_blend_minmax") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_blend_minmax                               : not detected." );
	}


	isGL_EXT_blend_subtract = isExtensionSupported("GL_EXT_blend_subtract");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_blend_subtract )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_blend_subtract                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_blend_subtract                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_blend_subtract") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_blend_subtract                             : not detected." );
	}


	isGL_EXT_clip_volume_hint = isExtensionSupported("GL_EXT_clip_volume_hint");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_clip_volume_hint )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_clip_volume_hint                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_clip_volume_hint                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_clip_volume_hint") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_clip_volume_hint                           : not detected." );
	}


	isGL_EXT_cmyka = isExtensionSupported("GL_EXT_cmyka");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_cmyka )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_cmyka                                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_cmyka                                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_cmyka") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_cmyka                                      : not detected." );
	}


	isGL_EXT_color_subtable = isExtensionSupported("GL_EXT_color_subtable");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_color_subtable ) // || isSEDEnable()
	{
		glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC) getExtensionPtr( "glColorSubTableEXT" );
		if ( glColorSubTableEXT != 0 )	++localInitializedProcCount;

		glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC) getExtensionPtr( "glCopyColorSubTableEXT" );
		if ( glCopyColorSubTableEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_color_subtable )

	if ( isGL_EXT_color_subtable )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_color_subtable                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_color_subtable                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_color_subtable") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_color_subtable                             : not detected." );
	}


	isGL_EXT_compiled_vertex_array = isExtensionSupported("GL_EXT_compiled_vertex_array");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_compiled_vertex_array ) // || isSEDEnable()
	{
		glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC) getExtensionPtr( "glLockArraysEXT" );
		if ( glLockArraysEXT != 0 )	++localInitializedProcCount;

		glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC) getExtensionPtr( "glUnlockArraysEXT" );
		if ( glUnlockArraysEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_compiled_vertex_array )

	if ( isGL_EXT_compiled_vertex_array )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_compiled_vertex_array                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_compiled_vertex_array                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_compiled_vertex_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_compiled_vertex_array                      : not detected." );
	}


	isGL_EXT_convolution = isExtensionSupported("GL_EXT_convolution");

	localSupportedProcCount		= 13;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_convolution ) // || isSEDEnable()
	{
		glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC) getExtensionPtr( "glConvolutionFilter1DEXT" );
		if ( glConvolutionFilter1DEXT != 0 )	++localInitializedProcCount;

		glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC) getExtensionPtr( "glConvolutionFilter2DEXT" );
		if ( glConvolutionFilter2DEXT != 0 )	++localInitializedProcCount;

		glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC) getExtensionPtr( "glConvolutionParameterfEXT" );
		if ( glConvolutionParameterfEXT != 0 )	++localInitializedProcCount;

		glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC) getExtensionPtr( "glConvolutionParameterfvEXT" );
		if ( glConvolutionParameterfvEXT != 0 )	++localInitializedProcCount;

		glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC) getExtensionPtr( "glConvolutionParameteriEXT" );
		if ( glConvolutionParameteriEXT != 0 )	++localInitializedProcCount;

		glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC) getExtensionPtr( "glConvolutionParameterivEXT" );
		if ( glConvolutionParameterivEXT != 0 )	++localInitializedProcCount;

		glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) getExtensionPtr( "glCopyConvolutionFilter1DEXT" );
		if ( glCopyConvolutionFilter1DEXT != 0 )	++localInitializedProcCount;

		glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) getExtensionPtr( "glCopyConvolutionFilter2DEXT" );
		if ( glCopyConvolutionFilter2DEXT != 0 )	++localInitializedProcCount;

		glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC) getExtensionPtr( "glGetConvolutionFilterEXT" );
		if ( glGetConvolutionFilterEXT != 0 )	++localInitializedProcCount;

		glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) getExtensionPtr( "glGetConvolutionParameterfvEXT" );
		if ( glGetConvolutionParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) getExtensionPtr( "glGetConvolutionParameterivEXT" );
		if ( glGetConvolutionParameterivEXT != 0 )	++localInitializedProcCount;

		glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC) getExtensionPtr( "glGetSeparableFilterEXT" );
		if ( glGetSeparableFilterEXT != 0 )	++localInitializedProcCount;

		glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC) getExtensionPtr( "glSeparableFilter2DEXT" );
		if ( glSeparableFilter2DEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_convolution )

	if ( isGL_EXT_convolution )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_convolution                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_convolution                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_convolution") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_convolution                                : not detected." );
	}


	isGL_EXT_coordinate_frame = isExtensionSupported("GL_EXT_coordinate_frame");

	localSupportedProcCount		= 22;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_coordinate_frame ) // || isSEDEnable()
	{
		glBinormal3bEXT = (PFNGLBINORMAL3BEXTPROC) getExtensionPtr( "glBinormal3bEXT" );
		if ( glBinormal3bEXT != 0 )	++localInitializedProcCount;

		glBinormal3bvEXT = (PFNGLBINORMAL3BVEXTPROC) getExtensionPtr( "glBinormal3bvEXT" );
		if ( glBinormal3bvEXT != 0 )	++localInitializedProcCount;

		glBinormal3dEXT = (PFNGLBINORMAL3DEXTPROC) getExtensionPtr( "glBinormal3dEXT" );
		if ( glBinormal3dEXT != 0 )	++localInitializedProcCount;

		glBinormal3dvEXT = (PFNGLBINORMAL3DVEXTPROC) getExtensionPtr( "glBinormal3dvEXT" );
		if ( glBinormal3dvEXT != 0 )	++localInitializedProcCount;

		glBinormal3fEXT = (PFNGLBINORMAL3FEXTPROC) getExtensionPtr( "glBinormal3fEXT" );
		if ( glBinormal3fEXT != 0 )	++localInitializedProcCount;

		glBinormal3fvEXT = (PFNGLBINORMAL3FVEXTPROC) getExtensionPtr( "glBinormal3fvEXT" );
		if ( glBinormal3fvEXT != 0 )	++localInitializedProcCount;

		glBinormal3iEXT = (PFNGLBINORMAL3IEXTPROC) getExtensionPtr( "glBinormal3iEXT" );
		if ( glBinormal3iEXT != 0 )	++localInitializedProcCount;

		glBinormal3ivEXT = (PFNGLBINORMAL3IVEXTPROC) getExtensionPtr( "glBinormal3ivEXT" );
		if ( glBinormal3ivEXT != 0 )	++localInitializedProcCount;

		glBinormal3sEXT = (PFNGLBINORMAL3SEXTPROC) getExtensionPtr( "glBinormal3sEXT" );
		if ( glBinormal3sEXT != 0 )	++localInitializedProcCount;

		glBinormal3svEXT = (PFNGLBINORMAL3SVEXTPROC) getExtensionPtr( "glBinormal3svEXT" );
		if ( glBinormal3svEXT != 0 )	++localInitializedProcCount;

		glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC) getExtensionPtr( "glBinormalPointerEXT" );
		if ( glBinormalPointerEXT != 0 )	++localInitializedProcCount;

		glTangent3bEXT = (PFNGLTANGENT3BEXTPROC) getExtensionPtr( "glTangent3bEXT" );
		if ( glTangent3bEXT != 0 )	++localInitializedProcCount;

		glTangent3bvEXT = (PFNGLTANGENT3BVEXTPROC) getExtensionPtr( "glTangent3bvEXT" );
		if ( glTangent3bvEXT != 0 )	++localInitializedProcCount;

		glTangent3dEXT = (PFNGLTANGENT3DEXTPROC) getExtensionPtr( "glTangent3dEXT" );
		if ( glTangent3dEXT != 0 )	++localInitializedProcCount;

		glTangent3dvEXT = (PFNGLTANGENT3DVEXTPROC) getExtensionPtr( "glTangent3dvEXT" );
		if ( glTangent3dvEXT != 0 )	++localInitializedProcCount;

		glTangent3fEXT = (PFNGLTANGENT3FEXTPROC) getExtensionPtr( "glTangent3fEXT" );
		if ( glTangent3fEXT != 0 )	++localInitializedProcCount;

		glTangent3fvEXT = (PFNGLTANGENT3FVEXTPROC) getExtensionPtr( "glTangent3fvEXT" );
		if ( glTangent3fvEXT != 0 )	++localInitializedProcCount;

		glTangent3iEXT = (PFNGLTANGENT3IEXTPROC) getExtensionPtr( "glTangent3iEXT" );
		if ( glTangent3iEXT != 0 )	++localInitializedProcCount;

		glTangent3ivEXT = (PFNGLTANGENT3IVEXTPROC) getExtensionPtr( "glTangent3ivEXT" );
		if ( glTangent3ivEXT != 0 )	++localInitializedProcCount;

		glTangent3sEXT = (PFNGLTANGENT3SEXTPROC) getExtensionPtr( "glTangent3sEXT" );
		if ( glTangent3sEXT != 0 )	++localInitializedProcCount;

		glTangent3svEXT = (PFNGLTANGENT3SVEXTPROC) getExtensionPtr( "glTangent3svEXT" );
		if ( glTangent3svEXT != 0 )	++localInitializedProcCount;

		glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC) getExtensionPtr( "glTangentPointerEXT" );
		if ( glTangentPointerEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_coordinate_frame )

	if ( isGL_EXT_coordinate_frame )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_coordinate_frame                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_coordinate_frame                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_coordinate_frame") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_coordinate_frame                           : not detected." );
	}


	isGL_EXT_copy_texture = isExtensionSupported("GL_EXT_copy_texture");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_copy_texture ) // || isSEDEnable()
	{
		glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC) getExtensionPtr( "glCopyTexImage1DEXT" );
		if ( glCopyTexImage1DEXT != 0 )	++localInitializedProcCount;

		glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC) getExtensionPtr( "glCopyTexImage2DEXT" );
		if ( glCopyTexImage2DEXT != 0 )	++localInitializedProcCount;

		glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC) getExtensionPtr( "glCopyTexSubImage1DEXT" );
		if ( glCopyTexSubImage1DEXT != 0 )	++localInitializedProcCount;

		glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC) getExtensionPtr( "glCopyTexSubImage2DEXT" );
		if ( glCopyTexSubImage2DEXT != 0 )	++localInitializedProcCount;

		glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC) getExtensionPtr( "glCopyTexSubImage3DEXT" );
		if ( glCopyTexSubImage3DEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_copy_texture )

	if ( isGL_EXT_copy_texture )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_copy_texture                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_copy_texture                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_copy_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_copy_texture                               : not detected." );
	}


	isGL_EXT_cull_vertex = isExtensionSupported("GL_EXT_cull_vertex");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_cull_vertex ) // || isSEDEnable()
	{
		glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC) getExtensionPtr( "glCullParameterdvEXT" );
		if ( glCullParameterdvEXT != 0 )	++localInitializedProcCount;

		glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC) getExtensionPtr( "glCullParameterfvEXT" );
		if ( glCullParameterfvEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_cull_vertex )

	if ( isGL_EXT_cull_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_cull_vertex                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_cull_vertex                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_cull_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_cull_vertex                                : not detected." );
	}


	isGL_EXT_depth_bounds_test = isExtensionSupported("GL_EXT_depth_bounds_test");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_depth_bounds_test ) // || isSEDEnable()
	{
		glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC) getExtensionPtr( "glDepthBoundsEXT" );
		if ( glDepthBoundsEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_depth_bounds_test )

	if ( isGL_EXT_depth_bounds_test )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_depth_bounds_test                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_depth_bounds_test                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_depth_bounds_test") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_depth_bounds_test                          : not detected." );
	}


	isGL_EXT_direct_state_access = isExtensionSupported("GL_EXT_direct_state_access");

	localSupportedProcCount		= 206;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_direct_state_access ) // || isSEDEnable()
	{
		glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC) getExtensionPtr( "glBindMultiTextureEXT" );
		if ( glBindMultiTextureEXT != 0 )	++localInitializedProcCount;

		glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) getExtensionPtr( "glCheckNamedFramebufferStatusEXT" );
		if ( glCheckNamedFramebufferStatusEXT != 0 )	++localInitializedProcCount;

		glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC) getExtensionPtr( "glClientAttribDefaultEXT" );
		if ( glClientAttribDefaultEXT != 0 )	++localInitializedProcCount;

		glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) getExtensionPtr( "glCompressedMultiTexImage1DEXT" );
		if ( glCompressedMultiTexImage1DEXT != 0 )	++localInitializedProcCount;

		glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) getExtensionPtr( "glCompressedMultiTexImage2DEXT" );
		if ( glCompressedMultiTexImage2DEXT != 0 )	++localInitializedProcCount;

		glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) getExtensionPtr( "glCompressedMultiTexImage3DEXT" );
		if ( glCompressedMultiTexImage3DEXT != 0 )	++localInitializedProcCount;

		glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) getExtensionPtr( "glCompressedMultiTexSubImage1DEXT" );
		if ( glCompressedMultiTexSubImage1DEXT != 0 )	++localInitializedProcCount;

		glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) getExtensionPtr( "glCompressedMultiTexSubImage2DEXT" );
		if ( glCompressedMultiTexSubImage2DEXT != 0 )	++localInitializedProcCount;

		glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) getExtensionPtr( "glCompressedMultiTexSubImage3DEXT" );
		if ( glCompressedMultiTexSubImage3DEXT != 0 )	++localInitializedProcCount;

		glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) getExtensionPtr( "glCompressedTextureImage1DEXT" );
		if ( glCompressedTextureImage1DEXT != 0 )	++localInitializedProcCount;

		glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) getExtensionPtr( "glCompressedTextureImage2DEXT" );
		if ( glCompressedTextureImage2DEXT != 0 )	++localInitializedProcCount;

		glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) getExtensionPtr( "glCompressedTextureImage3DEXT" );
		if ( glCompressedTextureImage3DEXT != 0 )	++localInitializedProcCount;

		glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) getExtensionPtr( "glCompressedTextureSubImage1DEXT" );
		if ( glCompressedTextureSubImage1DEXT != 0 )	++localInitializedProcCount;

		glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) getExtensionPtr( "glCompressedTextureSubImage2DEXT" );
		if ( glCompressedTextureSubImage2DEXT != 0 )	++localInitializedProcCount;

		glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) getExtensionPtr( "glCompressedTextureSubImage3DEXT" );
		if ( glCompressedTextureSubImage3DEXT != 0 )	++localInitializedProcCount;

		glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC) getExtensionPtr( "glCopyMultiTexImage1DEXT" );
		if ( glCopyMultiTexImage1DEXT != 0 )	++localInitializedProcCount;

		glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC) getExtensionPtr( "glCopyMultiTexImage2DEXT" );
		if ( glCopyMultiTexImage2DEXT != 0 )	++localInitializedProcCount;

		glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) getExtensionPtr( "glCopyMultiTexSubImage1DEXT" );
		if ( glCopyMultiTexSubImage1DEXT != 0 )	++localInitializedProcCount;

		glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) getExtensionPtr( "glCopyMultiTexSubImage2DEXT" );
		if ( glCopyMultiTexSubImage2DEXT != 0 )	++localInitializedProcCount;

		glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) getExtensionPtr( "glCopyMultiTexSubImage3DEXT" );
		if ( glCopyMultiTexSubImage3DEXT != 0 )	++localInitializedProcCount;

		glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC) getExtensionPtr( "glCopyTextureImage1DEXT" );
		if ( glCopyTextureImage1DEXT != 0 )	++localInitializedProcCount;

		glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC) getExtensionPtr( "glCopyTextureImage2DEXT" );
		if ( glCopyTextureImage2DEXT != 0 )	++localInitializedProcCount;

		glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) getExtensionPtr( "glCopyTextureSubImage1DEXT" );
		if ( glCopyTextureSubImage1DEXT != 0 )	++localInitializedProcCount;

		glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) getExtensionPtr( "glCopyTextureSubImage2DEXT" );
		if ( glCopyTextureSubImage2DEXT != 0 )	++localInitializedProcCount;

		glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) getExtensionPtr( "glCopyTextureSubImage3DEXT" );
		if ( glCopyTextureSubImage3DEXT != 0 )	++localInitializedProcCount;

		glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) getExtensionPtr( "glDisableClientStateIndexedEXT" );
		if ( glDisableClientStateIndexedEXT != 0 )	++localInitializedProcCount;

		glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) getExtensionPtr( "glEnableClientStateIndexedEXT" );
		if ( glEnableClientStateIndexedEXT != 0 )	++localInitializedProcCount;

		glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC) getExtensionPtr( "glFlushMappedNamedBufferRangeEXT" );
		if ( glFlushMappedNamedBufferRangeEXT != 0 )	++localInitializedProcCount;

		glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) getExtensionPtr( "glFramebufferDrawBufferEXT" );
		if ( glFramebufferDrawBufferEXT != 0 )	++localInitializedProcCount;

		glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) getExtensionPtr( "glFramebufferDrawBuffersEXT" );
		if ( glFramebufferDrawBuffersEXT != 0 )	++localInitializedProcCount;

		glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC) getExtensionPtr( "glFramebufferReadBufferEXT" );
		if ( glFramebufferReadBufferEXT != 0 )	++localInitializedProcCount;

		glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC) getExtensionPtr( "glGenerateMultiTexMipmapEXT" );
		if ( glGenerateMultiTexMipmapEXT != 0 )	++localInitializedProcCount;

		glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC) getExtensionPtr( "glGenerateTextureMipmapEXT" );
		if ( glGenerateTextureMipmapEXT != 0 )	++localInitializedProcCount;

		glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) getExtensionPtr( "glGetCompressedMultiTexImageEXT" );
		if ( glGetCompressedMultiTexImageEXT != 0 )	++localInitializedProcCount;

		glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) getExtensionPtr( "glGetCompressedTextureImageEXT" );
		if ( glGetCompressedTextureImageEXT != 0 )	++localInitializedProcCount;

		glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC) getExtensionPtr( "glGetDoubleIndexedvEXT" );
		if ( glGetDoubleIndexedvEXT != 0 )	++localInitializedProcCount;

		glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC) getExtensionPtr( "glGetFloatIndexedvEXT" );
		if ( glGetFloatIndexedvEXT != 0 )	++localInitializedProcCount;

		glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) getExtensionPtr( "glGetFramebufferParameterivEXT" );
		if ( glGetFramebufferParameterivEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC) getExtensionPtr( "glGetMultiTexEnvfvEXT" );
		if ( glGetMultiTexEnvfvEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC) getExtensionPtr( "glGetMultiTexEnvivEXT" );
		if ( glGetMultiTexEnvivEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC) getExtensionPtr( "glGetMultiTexGendvEXT" );
		if ( glGetMultiTexGendvEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC) getExtensionPtr( "glGetMultiTexGenfvEXT" );
		if ( glGetMultiTexGenfvEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC) getExtensionPtr( "glGetMultiTexGenivEXT" );
		if ( glGetMultiTexGenivEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC) getExtensionPtr( "glGetMultiTexImageEXT" );
		if ( glGetMultiTexImageEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) getExtensionPtr( "glGetMultiTexLevelParameterfvEXT" );
		if ( glGetMultiTexLevelParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) getExtensionPtr( "glGetMultiTexLevelParameterivEXT" );
		if ( glGetMultiTexLevelParameterivEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC) getExtensionPtr( "glGetMultiTexParameterIivEXT" );
		if ( glGetMultiTexParameterIivEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) getExtensionPtr( "glGetMultiTexParameterIuivEXT" );
		if ( glGetMultiTexParameterIuivEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC) getExtensionPtr( "glGetMultiTexParameterfvEXT" );
		if ( glGetMultiTexParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC) getExtensionPtr( "glGetMultiTexParameterivEXT" );
		if ( glGetMultiTexParameterivEXT != 0 )	++localInitializedProcCount;

		glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) getExtensionPtr( "glGetNamedBufferParameterivEXT" );
		if ( glGetNamedBufferParameterivEXT != 0 )	++localInitializedProcCount;

		glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) getExtensionPtr( "glGetNamedBufferPointervEXT" );
		if ( glGetNamedBufferPointervEXT != 0 )	++localInitializedProcCount;

		glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) getExtensionPtr( "glGetNamedBufferSubDataEXT" );
		if ( glGetNamedBufferSubDataEXT != 0 )	++localInitializedProcCount;

		glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) getExtensionPtr( "glGetNamedFramebufferAttachmentParameterivEXT" );
		if ( glGetNamedFramebufferAttachmentParameterivEXT != 0 )	++localInitializedProcCount;

		glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) getExtensionPtr( "glGetNamedProgramLocalParameterIivEXT" );
		if ( glGetNamedProgramLocalParameterIivEXT != 0 )	++localInitializedProcCount;

		glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) getExtensionPtr( "glGetNamedProgramLocalParameterIuivEXT" );
		if ( glGetNamedProgramLocalParameterIuivEXT != 0 )	++localInitializedProcCount;

		glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) getExtensionPtr( "glGetNamedProgramLocalParameterdvEXT" );
		if ( glGetNamedProgramLocalParameterdvEXT != 0 )	++localInitializedProcCount;

		glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) getExtensionPtr( "glGetNamedProgramLocalParameterfvEXT" );
		if ( glGetNamedProgramLocalParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) getExtensionPtr( "glGetNamedProgramStringEXT" );
		if ( glGetNamedProgramStringEXT != 0 )	++localInitializedProcCount;

		glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC) getExtensionPtr( "glGetNamedProgramivEXT" );
		if ( glGetNamedProgramivEXT != 0 )	++localInitializedProcCount;

		glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) getExtensionPtr( "glGetNamedRenderbufferParameterivEXT" );
		if ( glGetNamedRenderbufferParameterivEXT != 0 )	++localInitializedProcCount;

		glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC) getExtensionPtr( "glGetPointerIndexedvEXT" );
		if ( glGetPointerIndexedvEXT != 0 )	++localInitializedProcCount;

		glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC) getExtensionPtr( "glGetTextureImageEXT" );
		if ( glGetTextureImageEXT != 0 )	++localInitializedProcCount;

		glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) getExtensionPtr( "glGetTextureLevelParameterfvEXT" );
		if ( glGetTextureLevelParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) getExtensionPtr( "glGetTextureLevelParameterivEXT" );
		if ( glGetTextureLevelParameterivEXT != 0 )	++localInitializedProcCount;

		glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC) getExtensionPtr( "glGetTextureParameterIivEXT" );
		if ( glGetTextureParameterIivEXT != 0 )	++localInitializedProcCount;

		glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) getExtensionPtr( "glGetTextureParameterIuivEXT" );
		if ( glGetTextureParameterIuivEXT != 0 )	++localInitializedProcCount;

		glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC) getExtensionPtr( "glGetTextureParameterfvEXT" );
		if ( glGetTextureParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC) getExtensionPtr( "glGetTextureParameterivEXT" );
		if ( glGetTextureParameterivEXT != 0 )	++localInitializedProcCount;

		glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC) getExtensionPtr( "glMapNamedBufferEXT" );
		if ( glMapNamedBufferEXT != 0 )	++localInitializedProcCount;

		glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC) getExtensionPtr( "glMapNamedBufferRangeEXT" );
		if ( glMapNamedBufferRangeEXT != 0 )	++localInitializedProcCount;

		glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC) getExtensionPtr( "glMatrixFrustumEXT" );
		if ( glMatrixFrustumEXT != 0 )	++localInitializedProcCount;

		glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC) getExtensionPtr( "glMatrixLoadIdentityEXT" );
		if ( glMatrixLoadIdentityEXT != 0 )	++localInitializedProcCount;

		glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC) getExtensionPtr( "glMatrixLoadTransposedEXT" );
		if ( glMatrixLoadTransposedEXT != 0 )	++localInitializedProcCount;

		glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC) getExtensionPtr( "glMatrixLoadTransposefEXT" );
		if ( glMatrixLoadTransposefEXT != 0 )	++localInitializedProcCount;

		glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC) getExtensionPtr( "glMatrixLoaddEXT" );
		if ( glMatrixLoaddEXT != 0 )	++localInitializedProcCount;

		glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC) getExtensionPtr( "glMatrixLoadfEXT" );
		if ( glMatrixLoadfEXT != 0 )	++localInitializedProcCount;

		glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC) getExtensionPtr( "glMatrixMultTransposedEXT" );
		if ( glMatrixMultTransposedEXT != 0 )	++localInitializedProcCount;

		glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC) getExtensionPtr( "glMatrixMultTransposefEXT" );
		if ( glMatrixMultTransposefEXT != 0 )	++localInitializedProcCount;

		glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC) getExtensionPtr( "glMatrixMultdEXT" );
		if ( glMatrixMultdEXT != 0 )	++localInitializedProcCount;

		glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC) getExtensionPtr( "glMatrixMultfEXT" );
		if ( glMatrixMultfEXT != 0 )	++localInitializedProcCount;

		glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC) getExtensionPtr( "glMatrixOrthoEXT" );
		if ( glMatrixOrthoEXT != 0 )	++localInitializedProcCount;

		glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC) getExtensionPtr( "glMatrixPopEXT" );
		if ( glMatrixPopEXT != 0 )	++localInitializedProcCount;

		glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC) getExtensionPtr( "glMatrixPushEXT" );
		if ( glMatrixPushEXT != 0 )	++localInitializedProcCount;

		glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC) getExtensionPtr( "glMatrixRotatedEXT" );
		if ( glMatrixRotatedEXT != 0 )	++localInitializedProcCount;

		glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC) getExtensionPtr( "glMatrixRotatefEXT" );
		if ( glMatrixRotatefEXT != 0 )	++localInitializedProcCount;

		glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC) getExtensionPtr( "glMatrixScaledEXT" );
		if ( glMatrixScaledEXT != 0 )	++localInitializedProcCount;

		glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC) getExtensionPtr( "glMatrixScalefEXT" );
		if ( glMatrixScalefEXT != 0 )	++localInitializedProcCount;

		glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC) getExtensionPtr( "glMatrixTranslatedEXT" );
		if ( glMatrixTranslatedEXT != 0 )	++localInitializedProcCount;

		glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC) getExtensionPtr( "glMatrixTranslatefEXT" );
		if ( glMatrixTranslatefEXT != 0 )	++localInitializedProcCount;

		glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC) getExtensionPtr( "glMultiTexBufferEXT" );
		if ( glMultiTexBufferEXT != 0 )	++localInitializedProcCount;

		glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC) getExtensionPtr( "glMultiTexCoordPointerEXT" );
		if ( glMultiTexCoordPointerEXT != 0 )	++localInitializedProcCount;

		glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC) getExtensionPtr( "glMultiTexEnvfEXT" );
		if ( glMultiTexEnvfEXT != 0 )	++localInitializedProcCount;

		glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC) getExtensionPtr( "glMultiTexEnvfvEXT" );
		if ( glMultiTexEnvfvEXT != 0 )	++localInitializedProcCount;

		glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC) getExtensionPtr( "glMultiTexEnviEXT" );
		if ( glMultiTexEnviEXT != 0 )	++localInitializedProcCount;

		glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC) getExtensionPtr( "glMultiTexEnvivEXT" );
		if ( glMultiTexEnvivEXT != 0 )	++localInitializedProcCount;

		glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC) getExtensionPtr( "glMultiTexGendEXT" );
		if ( glMultiTexGendEXT != 0 )	++localInitializedProcCount;

		glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC) getExtensionPtr( "glMultiTexGendvEXT" );
		if ( glMultiTexGendvEXT != 0 )	++localInitializedProcCount;

		glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC) getExtensionPtr( "glMultiTexGenfEXT" );
		if ( glMultiTexGenfEXT != 0 )	++localInitializedProcCount;

		glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC) getExtensionPtr( "glMultiTexGenfvEXT" );
		if ( glMultiTexGenfvEXT != 0 )	++localInitializedProcCount;

		glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC) getExtensionPtr( "glMultiTexGeniEXT" );
		if ( glMultiTexGeniEXT != 0 )	++localInitializedProcCount;

		glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC) getExtensionPtr( "glMultiTexGenivEXT" );
		if ( glMultiTexGenivEXT != 0 )	++localInitializedProcCount;

		glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC) getExtensionPtr( "glMultiTexImage1DEXT" );
		if ( glMultiTexImage1DEXT != 0 )	++localInitializedProcCount;

		glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC) getExtensionPtr( "glMultiTexImage2DEXT" );
		if ( glMultiTexImage2DEXT != 0 )	++localInitializedProcCount;

		glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC) getExtensionPtr( "glMultiTexImage3DEXT" );
		if ( glMultiTexImage3DEXT != 0 )	++localInitializedProcCount;

		glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC) getExtensionPtr( "glMultiTexParameterIivEXT" );
		if ( glMultiTexParameterIivEXT != 0 )	++localInitializedProcCount;

		glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC) getExtensionPtr( "glMultiTexParameterIuivEXT" );
		if ( glMultiTexParameterIuivEXT != 0 )	++localInitializedProcCount;

		glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC) getExtensionPtr( "glMultiTexParameterfEXT" );
		if ( glMultiTexParameterfEXT != 0 )	++localInitializedProcCount;

		glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC) getExtensionPtr( "glMultiTexParameterfvEXT" );
		if ( glMultiTexParameterfvEXT != 0 )	++localInitializedProcCount;

		glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC) getExtensionPtr( "glMultiTexParameteriEXT" );
		if ( glMultiTexParameteriEXT != 0 )	++localInitializedProcCount;

		glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC) getExtensionPtr( "glMultiTexParameterivEXT" );
		if ( glMultiTexParameterivEXT != 0 )	++localInitializedProcCount;

		glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC) getExtensionPtr( "glMultiTexRenderbufferEXT" );
		if ( glMultiTexRenderbufferEXT != 0 )	++localInitializedProcCount;

		glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC) getExtensionPtr( "glMultiTexSubImage1DEXT" );
		if ( glMultiTexSubImage1DEXT != 0 )	++localInitializedProcCount;

		glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC) getExtensionPtr( "glMultiTexSubImage2DEXT" );
		if ( glMultiTexSubImage2DEXT != 0 )	++localInitializedProcCount;

		glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC) getExtensionPtr( "glMultiTexSubImage3DEXT" );
		if ( glMultiTexSubImage3DEXT != 0 )	++localInitializedProcCount;

		glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC) getExtensionPtr( "glNamedBufferDataEXT" );
		if ( glNamedBufferDataEXT != 0 )	++localInitializedProcCount;

		glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC) getExtensionPtr( "glNamedBufferSubDataEXT" );
		if ( glNamedBufferSubDataEXT != 0 )	++localInitializedProcCount;

		glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) getExtensionPtr( "glNamedCopyBufferSubDataEXT" );
		if ( glNamedCopyBufferSubDataEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) getExtensionPtr( "glNamedFramebufferRenderbufferEXT" );
		if ( glNamedFramebufferRenderbufferEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) getExtensionPtr( "glNamedFramebufferTexture1DEXT" );
		if ( glNamedFramebufferTexture1DEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) getExtensionPtr( "glNamedFramebufferTexture2DEXT" );
		if ( glNamedFramebufferTexture2DEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) getExtensionPtr( "glNamedFramebufferTexture3DEXT" );
		if ( glNamedFramebufferTexture3DEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) getExtensionPtr( "glNamedFramebufferTextureEXT" );
		if ( glNamedFramebufferTextureEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) getExtensionPtr( "glNamedFramebufferTextureFaceEXT" );
		if ( glNamedFramebufferTextureFaceEXT != 0 )	++localInitializedProcCount;

		glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) getExtensionPtr( "glNamedFramebufferTextureLayerEXT" );
		if ( glNamedFramebufferTextureLayerEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) getExtensionPtr( "glNamedProgramLocalParameter4dEXT" );
		if ( glNamedProgramLocalParameter4dEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) getExtensionPtr( "glNamedProgramLocalParameter4dvEXT" );
		if ( glNamedProgramLocalParameter4dvEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) getExtensionPtr( "glNamedProgramLocalParameter4fEXT" );
		if ( glNamedProgramLocalParameter4fEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) getExtensionPtr( "glNamedProgramLocalParameter4fvEXT" );
		if ( glNamedProgramLocalParameter4fvEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) getExtensionPtr( "glNamedProgramLocalParameterI4iEXT" );
		if ( glNamedProgramLocalParameterI4iEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) getExtensionPtr( "glNamedProgramLocalParameterI4ivEXT" );
		if ( glNamedProgramLocalParameterI4ivEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) getExtensionPtr( "glNamedProgramLocalParameterI4uiEXT" );
		if ( glNamedProgramLocalParameterI4uiEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) getExtensionPtr( "glNamedProgramLocalParameterI4uivEXT" );
		if ( glNamedProgramLocalParameterI4uivEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) getExtensionPtr( "glNamedProgramLocalParameters4fvEXT" );
		if ( glNamedProgramLocalParameters4fvEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) getExtensionPtr( "glNamedProgramLocalParametersI4ivEXT" );
		if ( glNamedProgramLocalParametersI4ivEXT != 0 )	++localInitializedProcCount;

		glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) getExtensionPtr( "glNamedProgramLocalParametersI4uivEXT" );
		if ( glNamedProgramLocalParametersI4uivEXT != 0 )	++localInitializedProcCount;

		glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC) getExtensionPtr( "glNamedProgramStringEXT" );
		if ( glNamedProgramStringEXT != 0 )	++localInitializedProcCount;

		glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) getExtensionPtr( "glNamedRenderbufferStorageEXT" );
		if ( glNamedRenderbufferStorageEXT != 0 )	++localInitializedProcCount;

		glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) getExtensionPtr( "glNamedRenderbufferStorageMultisampleCoverageEXT" );
		if ( glNamedRenderbufferStorageMultisampleCoverageEXT != 0 )	++localInitializedProcCount;

		glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) getExtensionPtr( "glNamedRenderbufferStorageMultisampleEXT" );
		if ( glNamedRenderbufferStorageMultisampleEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1dEXT = (PFNGLPROGRAMUNIFORM1DEXTPROC) getExtensionPtr( "glProgramUniform1dEXT" );
		if ( glProgramUniform1dEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1dvEXT = (PFNGLPROGRAMUNIFORM1DVEXTPROC) getExtensionPtr( "glProgramUniform1dvEXT" );
		if ( glProgramUniform1dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC) getExtensionPtr( "glProgramUniform1fEXT" );
		if ( glProgramUniform1fEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC) getExtensionPtr( "glProgramUniform1fvEXT" );
		if ( glProgramUniform1fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC) getExtensionPtr( "glProgramUniform1iEXT" );
		if ( glProgramUniform1iEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC) getExtensionPtr( "glProgramUniform1ivEXT" );
		if ( glProgramUniform1ivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC) getExtensionPtr( "glProgramUniform1uiEXT" );
		if ( glProgramUniform1uiEXT != 0 )	++localInitializedProcCount;

		glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC) getExtensionPtr( "glProgramUniform1uivEXT" );
		if ( glProgramUniform1uivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2dEXT = (PFNGLPROGRAMUNIFORM2DEXTPROC) getExtensionPtr( "glProgramUniform2dEXT" );
		if ( glProgramUniform2dEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2dvEXT = (PFNGLPROGRAMUNIFORM2DVEXTPROC) getExtensionPtr( "glProgramUniform2dvEXT" );
		if ( glProgramUniform2dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC) getExtensionPtr( "glProgramUniform2fEXT" );
		if ( glProgramUniform2fEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC) getExtensionPtr( "glProgramUniform2fvEXT" );
		if ( glProgramUniform2fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC) getExtensionPtr( "glProgramUniform2iEXT" );
		if ( glProgramUniform2iEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC) getExtensionPtr( "glProgramUniform2ivEXT" );
		if ( glProgramUniform2ivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC) getExtensionPtr( "glProgramUniform2uiEXT" );
		if ( glProgramUniform2uiEXT != 0 )	++localInitializedProcCount;

		glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC) getExtensionPtr( "glProgramUniform2uivEXT" );
		if ( glProgramUniform2uivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3dEXT = (PFNGLPROGRAMUNIFORM3DEXTPROC) getExtensionPtr( "glProgramUniform3dEXT" );
		if ( glProgramUniform3dEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3dvEXT = (PFNGLPROGRAMUNIFORM3DVEXTPROC) getExtensionPtr( "glProgramUniform3dvEXT" );
		if ( glProgramUniform3dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC) getExtensionPtr( "glProgramUniform3fEXT" );
		if ( glProgramUniform3fEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC) getExtensionPtr( "glProgramUniform3fvEXT" );
		if ( glProgramUniform3fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC) getExtensionPtr( "glProgramUniform3iEXT" );
		if ( glProgramUniform3iEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC) getExtensionPtr( "glProgramUniform3ivEXT" );
		if ( glProgramUniform3ivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC) getExtensionPtr( "glProgramUniform3uiEXT" );
		if ( glProgramUniform3uiEXT != 0 )	++localInitializedProcCount;

		glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC) getExtensionPtr( "glProgramUniform3uivEXT" );
		if ( glProgramUniform3uivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4dEXT = (PFNGLPROGRAMUNIFORM4DEXTPROC) getExtensionPtr( "glProgramUniform4dEXT" );
		if ( glProgramUniform4dEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4dvEXT = (PFNGLPROGRAMUNIFORM4DVEXTPROC) getExtensionPtr( "glProgramUniform4dvEXT" );
		if ( glProgramUniform4dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC) getExtensionPtr( "glProgramUniform4fEXT" );
		if ( glProgramUniform4fEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC) getExtensionPtr( "glProgramUniform4fvEXT" );
		if ( glProgramUniform4fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC) getExtensionPtr( "glProgramUniform4iEXT" );
		if ( glProgramUniform4iEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC) getExtensionPtr( "glProgramUniform4ivEXT" );
		if ( glProgramUniform4ivEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC) getExtensionPtr( "glProgramUniform4uiEXT" );
		if ( glProgramUniform4uiEXT != 0 )	++localInitializedProcCount;

		glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC) getExtensionPtr( "glProgramUniform4uivEXT" );
		if ( glProgramUniform4uivEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix2dvEXT" );
		if ( glProgramUniformMatrix2dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix2fvEXT" );
		if ( glProgramUniformMatrix2fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix2x3dvEXT" );
		if ( glProgramUniformMatrix2x3dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix2x3fvEXT" );
		if ( glProgramUniformMatrix2x3fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix2x4dvEXT" );
		if ( glProgramUniformMatrix2x4dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix2x4fvEXT" );
		if ( glProgramUniformMatrix2x4fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix3dvEXT" );
		if ( glProgramUniformMatrix3dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix3fvEXT" );
		if ( glProgramUniformMatrix3fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix3x2dvEXT" );
		if ( glProgramUniformMatrix3x2dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix3x2fvEXT" );
		if ( glProgramUniformMatrix3x2fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix3x4dvEXT" );
		if ( glProgramUniformMatrix3x4dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix3x4fvEXT" );
		if ( glProgramUniformMatrix3x4fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix4dvEXT" );
		if ( glProgramUniformMatrix4dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix4fvEXT" );
		if ( glProgramUniformMatrix4fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix4x2dvEXT" );
		if ( glProgramUniformMatrix4x2dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix4x2fvEXT" );
		if ( glProgramUniformMatrix4x2fvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC) getExtensionPtr( "glProgramUniformMatrix4x3dvEXT" );
		if ( glProgramUniformMatrix4x3dvEXT != 0 )	++localInitializedProcCount;

		glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) getExtensionPtr( "glProgramUniformMatrix4x3fvEXT" );
		if ( glProgramUniformMatrix4x3fvEXT != 0 )	++localInitializedProcCount;

		glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) getExtensionPtr( "glPushClientAttribDefaultEXT" );
		if ( glPushClientAttribDefaultEXT != 0 )	++localInitializedProcCount;

		glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC) getExtensionPtr( "glTextureBufferEXT" );
		if ( glTextureBufferEXT != 0 )	++localInitializedProcCount;

		glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC) getExtensionPtr( "glTextureImage1DEXT" );
		if ( glTextureImage1DEXT != 0 )	++localInitializedProcCount;

		glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC) getExtensionPtr( "glTextureImage2DEXT" );
		if ( glTextureImage2DEXT != 0 )	++localInitializedProcCount;

		glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC) getExtensionPtr( "glTextureImage3DEXT" );
		if ( glTextureImage3DEXT != 0 )	++localInitializedProcCount;

		glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC) getExtensionPtr( "glTextureParameterIivEXT" );
		if ( glTextureParameterIivEXT != 0 )	++localInitializedProcCount;

		glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC) getExtensionPtr( "glTextureParameterIuivEXT" );
		if ( glTextureParameterIuivEXT != 0 )	++localInitializedProcCount;

		glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC) getExtensionPtr( "glTextureParameterfEXT" );
		if ( glTextureParameterfEXT != 0 )	++localInitializedProcCount;

		glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC) getExtensionPtr( "glTextureParameterfvEXT" );
		if ( glTextureParameterfvEXT != 0 )	++localInitializedProcCount;

		glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC) getExtensionPtr( "glTextureParameteriEXT" );
		if ( glTextureParameteriEXT != 0 )	++localInitializedProcCount;

		glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC) getExtensionPtr( "glTextureParameterivEXT" );
		if ( glTextureParameterivEXT != 0 )	++localInitializedProcCount;

		glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC) getExtensionPtr( "glTextureRenderbufferEXT" );
		if ( glTextureRenderbufferEXT != 0 )	++localInitializedProcCount;

		glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC) getExtensionPtr( "glTextureSubImage1DEXT" );
		if ( glTextureSubImage1DEXT != 0 )	++localInitializedProcCount;

		glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC) getExtensionPtr( "glTextureSubImage2DEXT" );
		if ( glTextureSubImage2DEXT != 0 )	++localInitializedProcCount;

		glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC) getExtensionPtr( "glTextureSubImage3DEXT" );
		if ( glTextureSubImage3DEXT != 0 )	++localInitializedProcCount;

		glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC) getExtensionPtr( "glUnmapNamedBufferEXT" );
		if ( glUnmapNamedBufferEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_direct_state_access )

	if ( isGL_EXT_direct_state_access )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_direct_state_access                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_direct_state_access                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_direct_state_access") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_direct_state_access                        : not detected." );
	}


	isGL_EXT_draw_buffers2 = isExtensionSupported("GL_EXT_draw_buffers2");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_draw_buffers2 ) // || isSEDEnable()
	{
		glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC) getExtensionPtr( "glColorMaskIndexedEXT" );
		if ( glColorMaskIndexedEXT != 0 )	++localInitializedProcCount;

		glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC) getExtensionPtr( "glDisableIndexedEXT" );
		if ( glDisableIndexedEXT != 0 )	++localInitializedProcCount;

		glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC) getExtensionPtr( "glEnableIndexedEXT" );
		if ( glEnableIndexedEXT != 0 )	++localInitializedProcCount;

		glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC) getExtensionPtr( "glGetBooleanIndexedvEXT" );
		if ( glGetBooleanIndexedvEXT != 0 )	++localInitializedProcCount;

		glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC) getExtensionPtr( "glGetIntegerIndexedvEXT" );
		if ( glGetIntegerIndexedvEXT != 0 )	++localInitializedProcCount;

		glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC) getExtensionPtr( "glIsEnabledIndexedEXT" );
		if ( glIsEnabledIndexedEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_draw_buffers2 )

	if ( isGL_EXT_draw_buffers2 )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_draw_buffers2                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_draw_buffers2                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_draw_buffers2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_draw_buffers2                              : not detected." );
	}


	isGL_EXT_draw_instanced = isExtensionSupported("GL_EXT_draw_instanced");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_draw_instanced ) // || isSEDEnable()
	{
		glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC) getExtensionPtr( "glDrawArraysInstancedEXT" );
		if ( glDrawArraysInstancedEXT != 0 )	++localInitializedProcCount;

		glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC) getExtensionPtr( "glDrawElementsInstancedEXT" );
		if ( glDrawElementsInstancedEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_draw_instanced )

	if ( isGL_EXT_draw_instanced )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_draw_instanced                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_draw_instanced                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_draw_instanced") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_draw_instanced                             : not detected." );
	}


	isGL_EXT_draw_range_elements = isExtensionSupported("GL_EXT_draw_range_elements");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_draw_range_elements ) // || isSEDEnable()
	{
		glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC) getExtensionPtr( "glDrawRangeElementsEXT" );
		if ( glDrawRangeElementsEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_draw_range_elements )

	if ( isGL_EXT_draw_range_elements )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_draw_range_elements                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_draw_range_elements                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_draw_range_elements") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_draw_range_elements                        : not detected." );
	}


	isGL_EXT_fog_coord = isExtensionSupported("GL_EXT_fog_coord");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_fog_coord ) // || isSEDEnable()
	{
		glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC) getExtensionPtr( "glFogCoordPointerEXT" );
		if ( glFogCoordPointerEXT != 0 )	++localInitializedProcCount;

		glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC) getExtensionPtr( "glFogCoorddEXT" );
		if ( glFogCoorddEXT != 0 )	++localInitializedProcCount;

		glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC) getExtensionPtr( "glFogCoorddvEXT" );
		if ( glFogCoorddvEXT != 0 )	++localInitializedProcCount;

		glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC) getExtensionPtr( "glFogCoordfEXT" );
		if ( glFogCoordfEXT != 0 )	++localInitializedProcCount;

		glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC) getExtensionPtr( "glFogCoordfvEXT" );
		if ( glFogCoordfvEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_fog_coord )

	if ( isGL_EXT_fog_coord )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_fog_coord                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_fog_coord                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_fog_coord") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_fog_coord                                  : not detected." );
	}


	isGL_EXT_framebuffer_blit = isExtensionSupported("GL_EXT_framebuffer_blit");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_framebuffer_blit ) // || isSEDEnable()
	{
		glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC) getExtensionPtr( "glBlitFramebufferEXT" );
		if ( glBlitFramebufferEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_framebuffer_blit )

	if ( isGL_EXT_framebuffer_blit )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_framebuffer_blit                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_framebuffer_blit                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_framebuffer_blit") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_framebuffer_blit                           : not detected." );
	}


	isGL_EXT_framebuffer_multisample = isExtensionSupported("GL_EXT_framebuffer_multisample");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_framebuffer_multisample ) // || isSEDEnable()
	{
		glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) getExtensionPtr( "glRenderbufferStorageMultisampleEXT" );
		if ( glRenderbufferStorageMultisampleEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_framebuffer_multisample )

	if ( isGL_EXT_framebuffer_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_framebuffer_multisample                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_framebuffer_multisample                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_framebuffer_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_framebuffer_multisample                    : not detected." );
	}


	isGL_EXT_framebuffer_multisample_blit_scaled = isExtensionSupported("GL_EXT_framebuffer_multisample_blit_scaled");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_framebuffer_multisample_blit_scaled )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_framebuffer_multisample_blit_scaled        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_framebuffer_multisample_blit_scaled        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_framebuffer_multisample_blit_scaled") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_framebuffer_multisample_blit_scaled        : not detected." );
	}


	isGL_EXT_framebuffer_object = isExtensionSupported("GL_EXT_framebuffer_object");

	localSupportedProcCount		= 17;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_framebuffer_object ) // || isSEDEnable()
	{
		glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) getExtensionPtr( "glBindFramebufferEXT" );
		if ( glBindFramebufferEXT != 0 )	++localInitializedProcCount;

		glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) getExtensionPtr( "glBindRenderbufferEXT" );
		if ( glBindRenderbufferEXT != 0 )	++localInitializedProcCount;

		glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) getExtensionPtr( "glCheckFramebufferStatusEXT" );
		if ( glCheckFramebufferStatusEXT != 0 )	++localInitializedProcCount;

		glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) getExtensionPtr( "glDeleteFramebuffersEXT" );
		if ( glDeleteFramebuffersEXT != 0 )	++localInitializedProcCount;

		glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) getExtensionPtr( "glDeleteRenderbuffersEXT" );
		if ( glDeleteRenderbuffersEXT != 0 )	++localInitializedProcCount;

		glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) getExtensionPtr( "glFramebufferRenderbufferEXT" );
		if ( glFramebufferRenderbufferEXT != 0 )	++localInitializedProcCount;

		glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) getExtensionPtr( "glFramebufferTexture1DEXT" );
		if ( glFramebufferTexture1DEXT != 0 )	++localInitializedProcCount;

		glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) getExtensionPtr( "glFramebufferTexture2DEXT" );
		if ( glFramebufferTexture2DEXT != 0 )	++localInitializedProcCount;

		glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) getExtensionPtr( "glFramebufferTexture3DEXT" );
		if ( glFramebufferTexture3DEXT != 0 )	++localInitializedProcCount;

		glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) getExtensionPtr( "glGenFramebuffersEXT" );
		if ( glGenFramebuffersEXT != 0 )	++localInitializedProcCount;

		glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) getExtensionPtr( "glGenRenderbuffersEXT" );
		if ( glGenRenderbuffersEXT != 0 )	++localInitializedProcCount;

		glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) getExtensionPtr( "glGenerateMipmapEXT" );
		if ( glGenerateMipmapEXT != 0 )	++localInitializedProcCount;

		glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) getExtensionPtr( "glGetFramebufferAttachmentParameterivEXT" );
		if ( glGetFramebufferAttachmentParameterivEXT != 0 )	++localInitializedProcCount;

		glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) getExtensionPtr( "glGetRenderbufferParameterivEXT" );
		if ( glGetRenderbufferParameterivEXT != 0 )	++localInitializedProcCount;

		glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC) getExtensionPtr( "glIsFramebufferEXT" );
		if ( glIsFramebufferEXT != 0 )	++localInitializedProcCount;

		glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) getExtensionPtr( "glIsRenderbufferEXT" );
		if ( glIsRenderbufferEXT != 0 )	++localInitializedProcCount;

		glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) getExtensionPtr( "glRenderbufferStorageEXT" );
		if ( glRenderbufferStorageEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_framebuffer_object )

	if ( isGL_EXT_framebuffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_framebuffer_object                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_framebuffer_object                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_framebuffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_framebuffer_object                         : not detected." );
	}


	isGL_EXT_framebuffer_sRGB = isExtensionSupported("GL_EXT_framebuffer_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_framebuffer_sRGB )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_framebuffer_sRGB                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_framebuffer_sRGB                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_framebuffer_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_framebuffer_sRGB                           : not detected." );
	}


	isGL_EXT_geometry_shader4 = isExtensionSupported("GL_EXT_geometry_shader4");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_geometry_shader4 ) // || isSEDEnable()
	{
		glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC) getExtensionPtr( "glProgramParameteriEXT" );
		if ( glProgramParameteriEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_geometry_shader4 )

	if ( isGL_EXT_geometry_shader4 )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_geometry_shader4                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_geometry_shader4                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_geometry_shader4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_geometry_shader4                           : not detected." );
	}


	isGL_EXT_gpu_program_parameters = isExtensionSupported("GL_EXT_gpu_program_parameters");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_gpu_program_parameters ) // || isSEDEnable()
	{
		glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC) getExtensionPtr( "glProgramEnvParameters4fvEXT" );
		if ( glProgramEnvParameters4fvEXT != 0 )	++localInitializedProcCount;

		glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC) getExtensionPtr( "glProgramLocalParameters4fvEXT" );
		if ( glProgramLocalParameters4fvEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_gpu_program_parameters )

	if ( isGL_EXT_gpu_program_parameters )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_gpu_program_parameters                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_gpu_program_parameters                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_gpu_program_parameters") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_gpu_program_parameters                     : not detected." );
	}


	isGL_EXT_gpu_shader4 = isExtensionSupported("GL_EXT_gpu_shader4");

	localSupportedProcCount		= 11;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_gpu_shader4 ) // || isSEDEnable()
	{
		glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC) getExtensionPtr( "glBindFragDataLocationEXT" );
		if ( glBindFragDataLocationEXT != 0 )	++localInitializedProcCount;

		glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC) getExtensionPtr( "glGetFragDataLocationEXT" );
		if ( glGetFragDataLocationEXT != 0 )	++localInitializedProcCount;

		glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC) getExtensionPtr( "glGetUniformuivEXT" );
		if ( glGetUniformuivEXT != 0 )	++localInitializedProcCount;

		glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC) getExtensionPtr( "glUniform1uiEXT" );
		if ( glUniform1uiEXT != 0 )	++localInitializedProcCount;

		glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC) getExtensionPtr( "glUniform1uivEXT" );
		if ( glUniform1uivEXT != 0 )	++localInitializedProcCount;

		glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC) getExtensionPtr( "glUniform2uiEXT" );
		if ( glUniform2uiEXT != 0 )	++localInitializedProcCount;

		glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC) getExtensionPtr( "glUniform2uivEXT" );
		if ( glUniform2uivEXT != 0 )	++localInitializedProcCount;

		glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC) getExtensionPtr( "glUniform3uiEXT" );
		if ( glUniform3uiEXT != 0 )	++localInitializedProcCount;

		glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC) getExtensionPtr( "glUniform3uivEXT" );
		if ( glUniform3uivEXT != 0 )	++localInitializedProcCount;

		glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC) getExtensionPtr( "glUniform4uiEXT" );
		if ( glUniform4uiEXT != 0 )	++localInitializedProcCount;

		glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC) getExtensionPtr( "glUniform4uivEXT" );
		if ( glUniform4uivEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_gpu_shader4 )

	if ( isGL_EXT_gpu_shader4 )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_gpu_shader4                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_gpu_shader4                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_gpu_shader4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_gpu_shader4                                : not detected." );
	}


	isGL_EXT_histogram = isExtensionSupported("GL_EXT_histogram");

	localSupportedProcCount		= 10;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_histogram ) // || isSEDEnable()
	{
		glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC) getExtensionPtr( "glGetHistogramEXT" );
		if ( glGetHistogramEXT != 0 )	++localInitializedProcCount;

		glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) getExtensionPtr( "glGetHistogramParameterfvEXT" );
		if ( glGetHistogramParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) getExtensionPtr( "glGetHistogramParameterivEXT" );
		if ( glGetHistogramParameterivEXT != 0 )	++localInitializedProcCount;

		glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC) getExtensionPtr( "glGetMinmaxEXT" );
		if ( glGetMinmaxEXT != 0 )	++localInitializedProcCount;

		glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC) getExtensionPtr( "glGetMinmaxParameterfvEXT" );
		if ( glGetMinmaxParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC) getExtensionPtr( "glGetMinmaxParameterivEXT" );
		if ( glGetMinmaxParameterivEXT != 0 )	++localInitializedProcCount;

		glHistogramEXT = (PFNGLHISTOGRAMEXTPROC) getExtensionPtr( "glHistogramEXT" );
		if ( glHistogramEXT != 0 )	++localInitializedProcCount;

		glMinmaxEXT = (PFNGLMINMAXEXTPROC) getExtensionPtr( "glMinmaxEXT" );
		if ( glMinmaxEXT != 0 )	++localInitializedProcCount;

		glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC) getExtensionPtr( "glResetHistogramEXT" );
		if ( glResetHistogramEXT != 0 )	++localInitializedProcCount;

		glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC) getExtensionPtr( "glResetMinmaxEXT" );
		if ( glResetMinmaxEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_histogram )

	if ( isGL_EXT_histogram )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_histogram                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_histogram                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_histogram") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_histogram                                  : not detected." );
	}


	isGL_EXT_index_array_formats = isExtensionSupported("GL_EXT_index_array_formats");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_index_array_formats )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_index_array_formats                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_index_array_formats                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_index_array_formats") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_index_array_formats                        : not detected." );
	}


	isGL_EXT_index_func = isExtensionSupported("GL_EXT_index_func");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_index_func ) // || isSEDEnable()
	{
		glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC) getExtensionPtr( "glIndexFuncEXT" );
		if ( glIndexFuncEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_index_func )

	if ( isGL_EXT_index_func )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_index_func                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_index_func                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_index_func") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_index_func                                 : not detected." );
	}


	isGL_EXT_index_material = isExtensionSupported("GL_EXT_index_material");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_index_material ) // || isSEDEnable()
	{
		glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC) getExtensionPtr( "glIndexMaterialEXT" );
		if ( glIndexMaterialEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_index_material )

	if ( isGL_EXT_index_material )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_index_material                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_index_material                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_index_material") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_index_material                             : not detected." );
	}


	isGL_EXT_index_texture = isExtensionSupported("GL_EXT_index_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_index_texture )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_index_texture                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_index_texture                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_index_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_index_texture                              : not detected." );
	}


	isGL_EXT_light_texture = isExtensionSupported("GL_EXT_light_texture");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_light_texture ) // || isSEDEnable()
	{
		glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC) getExtensionPtr( "glApplyTextureEXT" );
		if ( glApplyTextureEXT != 0 )	++localInitializedProcCount;

		glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC) getExtensionPtr( "glTextureLightEXT" );
		if ( glTextureLightEXT != 0 )	++localInitializedProcCount;

		glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC) getExtensionPtr( "glTextureMaterialEXT" );
		if ( glTextureMaterialEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_light_texture )

	if ( isGL_EXT_light_texture )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_light_texture                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_light_texture                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_light_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_light_texture                              : not detected." );
	}


	isGL_EXT_misc_attribute = isExtensionSupported("GL_EXT_misc_attribute");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_misc_attribute )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_misc_attribute                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_misc_attribute                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_misc_attribute") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_misc_attribute                             : not detected." );
	}


	isGL_EXT_multi_draw_arrays = isExtensionSupported("GL_EXT_multi_draw_arrays");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_multi_draw_arrays ) // || isSEDEnable()
	{
		glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC) getExtensionPtr( "glMultiDrawArraysEXT" );
		if ( glMultiDrawArraysEXT != 0 )	++localInitializedProcCount;

		glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC) getExtensionPtr( "glMultiDrawElementsEXT" );
		if ( glMultiDrawElementsEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_multi_draw_arrays )

	if ( isGL_EXT_multi_draw_arrays )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_multi_draw_arrays                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_multi_draw_arrays                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_multi_draw_arrays") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_multi_draw_arrays                          : not detected." );
	}


	isGL_EXT_multisample = isExtensionSupported("GL_EXT_multisample");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_multisample ) // || isSEDEnable()
	{
		glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC) getExtensionPtr( "glSampleMaskEXT" );
		if ( glSampleMaskEXT != 0 )	++localInitializedProcCount;

		glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC) getExtensionPtr( "glSamplePatternEXT" );
		if ( glSamplePatternEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_multisample )

	if ( isGL_EXT_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_multisample                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_multisample                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_multisample                                : not detected." );
	}


	isGL_EXT_packed_depth_stencil = isExtensionSupported("GL_EXT_packed_depth_stencil");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_packed_depth_stencil )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_packed_depth_stencil                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_packed_depth_stencil                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_packed_depth_stencil") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_packed_depth_stencil                       : not detected." );
	}


	isGL_EXT_packed_float = isExtensionSupported("GL_EXT_packed_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_packed_float )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_packed_float                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_packed_float                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_packed_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_packed_float                               : not detected." );
	}


	isGL_EXT_packed_pixels = isExtensionSupported("GL_EXT_packed_pixels");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_packed_pixels )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_packed_pixels                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_packed_pixels                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_packed_pixels") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_packed_pixels                              : not detected." );
	}


	isGL_EXT_paletted_texture = isExtensionSupported("GL_EXT_paletted_texture");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_paletted_texture ) // || isSEDEnable()
	{
		glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) getExtensionPtr( "glColorTableEXT" );
		if ( glColorTableEXT != 0 )	++localInitializedProcCount;

		glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC) getExtensionPtr( "glGetColorTableEXT" );
		if ( glGetColorTableEXT != 0 )	++localInitializedProcCount;

		glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) getExtensionPtr( "glGetColorTableParameterfvEXT" );
		if ( glGetColorTableParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) getExtensionPtr( "glGetColorTableParameterivEXT" );
		if ( glGetColorTableParameterivEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_paletted_texture )

	if ( isGL_EXT_paletted_texture )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_paletted_texture                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_paletted_texture                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_paletted_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_paletted_texture                           : not detected." );
	}


	isGL_EXT_pixel_buffer_object = isExtensionSupported("GL_EXT_pixel_buffer_object");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_pixel_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_pixel_buffer_object                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_pixel_buffer_object                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_pixel_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_pixel_buffer_object                        : not detected." );
	}


	isGL_EXT_pixel_transform = isExtensionSupported("GL_EXT_pixel_transform");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_pixel_transform ) // || isSEDEnable()
	{
		glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC) getExtensionPtr( "glGetPixelTransformParameterfvEXT" );
		if ( glGetPixelTransformParameterfvEXT != 0 )	++localInitializedProcCount;

		glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC) getExtensionPtr( "glGetPixelTransformParameterivEXT" );
		if ( glGetPixelTransformParameterivEXT != 0 )	++localInitializedProcCount;

		glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) getExtensionPtr( "glPixelTransformParameterfEXT" );
		if ( glPixelTransformParameterfEXT != 0 )	++localInitializedProcCount;

		glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) getExtensionPtr( "glPixelTransformParameterfvEXT" );
		if ( glPixelTransformParameterfvEXT != 0 )	++localInitializedProcCount;

		glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) getExtensionPtr( "glPixelTransformParameteriEXT" );
		if ( glPixelTransformParameteriEXT != 0 )	++localInitializedProcCount;

		glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) getExtensionPtr( "glPixelTransformParameterivEXT" );
		if ( glPixelTransformParameterivEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_pixel_transform )

	if ( isGL_EXT_pixel_transform )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_pixel_transform                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_pixel_transform                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_pixel_transform") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_pixel_transform                            : not detected." );
	}


	isGL_EXT_pixel_transform_color_table = isExtensionSupported("GL_EXT_pixel_transform_color_table");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_pixel_transform_color_table )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_pixel_transform_color_table                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_pixel_transform_color_table                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_pixel_transform_color_table") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_pixel_transform_color_table                : not detected." );
	}


	isGL_EXT_point_parameters = isExtensionSupported("GL_EXT_point_parameters");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_point_parameters ) // || isSEDEnable()
	{
		glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC) getExtensionPtr( "glPointParameterfEXT" );
		if ( glPointParameterfEXT != 0 )	++localInitializedProcCount;

		glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC) getExtensionPtr( "glPointParameterfvEXT" );
		if ( glPointParameterfvEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_point_parameters )

	if ( isGL_EXT_point_parameters )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_point_parameters                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_point_parameters                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_point_parameters") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_point_parameters                           : not detected." );
	}


	isGL_EXT_polygon_offset = isExtensionSupported("GL_EXT_polygon_offset");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_polygon_offset ) // || isSEDEnable()
	{
		glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC) getExtensionPtr( "glPolygonOffsetEXT" );
		if ( glPolygonOffsetEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_polygon_offset )

	if ( isGL_EXT_polygon_offset )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_polygon_offset                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_polygon_offset                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_polygon_offset") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_polygon_offset                             : not detected." );
	}


	isGL_EXT_provoking_vertex = isExtensionSupported("GL_EXT_provoking_vertex");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_provoking_vertex ) // || isSEDEnable()
	{
		glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC) getExtensionPtr( "glProvokingVertexEXT" );
		if ( glProvokingVertexEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_provoking_vertex )

	if ( isGL_EXT_provoking_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_provoking_vertex                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_provoking_vertex                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_provoking_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_provoking_vertex                           : not detected." );
	}


	isGL_EXT_rescale_normal = isExtensionSupported("GL_EXT_rescale_normal");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_rescale_normal )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_rescale_normal                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_rescale_normal                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_rescale_normal") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_rescale_normal                             : not detected." );
	}


	isGL_EXT_secondary_color = isExtensionSupported("GL_EXT_secondary_color");

	localSupportedProcCount		= 17;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_secondary_color ) // || isSEDEnable()
	{
		glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC) getExtensionPtr( "glSecondaryColor3bEXT" );
		if ( glSecondaryColor3bEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC) getExtensionPtr( "glSecondaryColor3bvEXT" );
		if ( glSecondaryColor3bvEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC) getExtensionPtr( "glSecondaryColor3dEXT" );
		if ( glSecondaryColor3dEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC) getExtensionPtr( "glSecondaryColor3dvEXT" );
		if ( glSecondaryColor3dvEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC) getExtensionPtr( "glSecondaryColor3fEXT" );
		if ( glSecondaryColor3fEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC) getExtensionPtr( "glSecondaryColor3fvEXT" );
		if ( glSecondaryColor3fvEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC) getExtensionPtr( "glSecondaryColor3iEXT" );
		if ( glSecondaryColor3iEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC) getExtensionPtr( "glSecondaryColor3ivEXT" );
		if ( glSecondaryColor3ivEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC) getExtensionPtr( "glSecondaryColor3sEXT" );
		if ( glSecondaryColor3sEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC) getExtensionPtr( "glSecondaryColor3svEXT" );
		if ( glSecondaryColor3svEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC) getExtensionPtr( "glSecondaryColor3ubEXT" );
		if ( glSecondaryColor3ubEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC) getExtensionPtr( "glSecondaryColor3ubvEXT" );
		if ( glSecondaryColor3ubvEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC) getExtensionPtr( "glSecondaryColor3uiEXT" );
		if ( glSecondaryColor3uiEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC) getExtensionPtr( "glSecondaryColor3uivEXT" );
		if ( glSecondaryColor3uivEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC) getExtensionPtr( "glSecondaryColor3usEXT" );
		if ( glSecondaryColor3usEXT != 0 )	++localInitializedProcCount;

		glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC) getExtensionPtr( "glSecondaryColor3usvEXT" );
		if ( glSecondaryColor3usvEXT != 0 )	++localInitializedProcCount;

		glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC) getExtensionPtr( "glSecondaryColorPointerEXT" );
		if ( glSecondaryColorPointerEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_secondary_color )

	if ( isGL_EXT_secondary_color )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_secondary_color                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_secondary_color                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_secondary_color") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_secondary_color                            : not detected." );
	}


	isGL_EXT_separate_shader_objects = isExtensionSupported("GL_EXT_separate_shader_objects");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_separate_shader_objects ) // || isSEDEnable()
	{
		glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC) getExtensionPtr( "glActiveProgramEXT" );
		if ( glActiveProgramEXT != 0 )	++localInitializedProcCount;

		glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC) getExtensionPtr( "glCreateShaderProgramEXT" );
		if ( glCreateShaderProgramEXT != 0 )	++localInitializedProcCount;

		glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC) getExtensionPtr( "glUseShaderProgramEXT" );
		if ( glUseShaderProgramEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_separate_shader_objects )

	if ( isGL_EXT_separate_shader_objects )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_separate_shader_objects                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_separate_shader_objects                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_separate_shader_objects") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_separate_shader_objects                    : not detected." );
	}


	isGL_EXT_separate_specular_color = isExtensionSupported("GL_EXT_separate_specular_color");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_separate_specular_color )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_separate_specular_color                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_separate_specular_color                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_separate_specular_color") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_separate_specular_color                    : not detected." );
	}


	isGL_EXT_shader_image_load_store = isExtensionSupported("GL_EXT_shader_image_load_store");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_shader_image_load_store ) // || isSEDEnable()
	{
		glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC) getExtensionPtr( "glBindImageTextureEXT" );
		if ( glBindImageTextureEXT != 0 )	++localInitializedProcCount;

		glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC) getExtensionPtr( "glMemoryBarrierEXT" );
		if ( glMemoryBarrierEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_shader_image_load_store )

	if ( isGL_EXT_shader_image_load_store )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_shader_image_load_store                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_shader_image_load_store                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_shader_image_load_store") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_shader_image_load_store                    : not detected." );
	}


	isGL_EXT_shadow_funcs = isExtensionSupported("GL_EXT_shadow_funcs");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_shadow_funcs )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_shadow_funcs                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_shadow_funcs                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_shadow_funcs") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_shadow_funcs                               : not detected." );
	}


	isGL_EXT_shared_texture_palette = isExtensionSupported("GL_EXT_shared_texture_palette");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_shared_texture_palette )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_shared_texture_palette                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_shared_texture_palette                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_shared_texture_palette") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_shared_texture_palette                     : not detected." );
	}


	isGL_EXT_stencil_clear_tag = isExtensionSupported("GL_EXT_stencil_clear_tag");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_stencil_clear_tag ) // || isSEDEnable()
	{
		glStencilClearTagEXT = (PFNGLSTENCILCLEARTAGEXTPROC) getExtensionPtr( "glStencilClearTagEXT" );
		if ( glStencilClearTagEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_stencil_clear_tag )

	if ( isGL_EXT_stencil_clear_tag )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_stencil_clear_tag                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_stencil_clear_tag                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_stencil_clear_tag") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_stencil_clear_tag                          : not detected." );
	}


	isGL_EXT_stencil_two_side = isExtensionSupported("GL_EXT_stencil_two_side");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_stencil_two_side ) // || isSEDEnable()
	{
		glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC) getExtensionPtr( "glActiveStencilFaceEXT" );
		if ( glActiveStencilFaceEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_stencil_two_side )

	if ( isGL_EXT_stencil_two_side )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_stencil_two_side                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_stencil_two_side                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_stencil_two_side") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_stencil_two_side                           : not detected." );
	}


	isGL_EXT_stencil_wrap = isExtensionSupported("GL_EXT_stencil_wrap");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_stencil_wrap )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_stencil_wrap                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_stencil_wrap                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_stencil_wrap") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_stencil_wrap                               : not detected." );
	}


	isGL_EXT_subtexture = isExtensionSupported("GL_EXT_subtexture");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_subtexture ) // || isSEDEnable()
	{
		glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC) getExtensionPtr( "glTexSubImage1DEXT" );
		if ( glTexSubImage1DEXT != 0 )	++localInitializedProcCount;

		glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC) getExtensionPtr( "glTexSubImage2DEXT" );
		if ( glTexSubImage2DEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_subtexture )

	if ( isGL_EXT_subtexture )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_subtexture                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_subtexture                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_subtexture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_subtexture                                 : not detected." );
	}


	isGL_EXT_texture = isExtensionSupported("GL_EXT_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture                                    : not detected." );
	}


	isGL_EXT_texture3D = isExtensionSupported("GL_EXT_texture3D");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture3D ) // || isSEDEnable()
	{
		glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC) getExtensionPtr( "glTexImage3DEXT" );
		if ( glTexImage3DEXT != 0 )	++localInitializedProcCount;

		glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC) getExtensionPtr( "glTexSubImage3DEXT" );
		if ( glTexSubImage3DEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_texture3D )

	if ( isGL_EXT_texture3D )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture3D                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture3D                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture3D") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture3D                                  : not detected." );
	}


	isGL_EXT_texture_array = isExtensionSupported("GL_EXT_texture_array");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_array )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_array                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_array                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_array                              : not detected." );
	}


	isGL_EXT_texture_buffer_object = isExtensionSupported("GL_EXT_texture_buffer_object");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_buffer_object ) // || isSEDEnable()
	{
		glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC) getExtensionPtr( "glTexBufferEXT" );
		if ( glTexBufferEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_texture_buffer_object )

	if ( isGL_EXT_texture_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_buffer_object                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_buffer_object                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_buffer_object                      : not detected." );
	}


	isGL_EXT_texture_compression_latc = isExtensionSupported("GL_EXT_texture_compression_latc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_compression_latc )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_compression_latc                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_compression_latc                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_compression_latc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_compression_latc                   : not detected." );
	}


	isGL_EXT_texture_compression_rgtc = isExtensionSupported("GL_EXT_texture_compression_rgtc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_compression_rgtc )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_compression_rgtc                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_compression_rgtc                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_compression_rgtc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_compression_rgtc                   : not detected." );
	}


	isGL_EXT_texture_compression_s3tc = isExtensionSupported("GL_EXT_texture_compression_s3tc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_compression_s3tc )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_compression_s3tc                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_compression_s3tc                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_compression_s3tc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_compression_s3tc                   : not detected." );
	}


	isGL_EXT_texture_cube_map = isExtensionSupported("GL_EXT_texture_cube_map");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_cube_map )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_cube_map                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_cube_map                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_cube_map") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_cube_map                           : not detected." );
	}


	isGL_EXT_texture_env_add = isExtensionSupported("GL_EXT_texture_env_add");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_env_add )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_env_add                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_env_add                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_env_add") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_env_add                            : not detected." );
	}


	isGL_EXT_texture_env_combine = isExtensionSupported("GL_EXT_texture_env_combine");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_env_combine )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_env_combine                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_env_combine                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_env_combine") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_env_combine                        : not detected." );
	}


	isGL_EXT_texture_env_dot3 = isExtensionSupported("GL_EXT_texture_env_dot3");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_env_dot3 )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_env_dot3                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_env_dot3                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_env_dot3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_env_dot3                           : not detected." );
	}


	isGL_EXT_texture_filter_anisotropic = isExtensionSupported("GL_EXT_texture_filter_anisotropic");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_filter_anisotropic )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_filter_anisotropic                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_filter_anisotropic                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_filter_anisotropic") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_filter_anisotropic                 : not detected." );
	}


	isGL_EXT_texture_integer = isExtensionSupported("GL_EXT_texture_integer");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_integer ) // || isSEDEnable()
	{
		glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC) getExtensionPtr( "glClearColorIiEXT" );
		if ( glClearColorIiEXT != 0 )	++localInitializedProcCount;

		glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC) getExtensionPtr( "glClearColorIuiEXT" );
		if ( glClearColorIuiEXT != 0 )	++localInitializedProcCount;

		glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC) getExtensionPtr( "glGetTexParameterIivEXT" );
		if ( glGetTexParameterIivEXT != 0 )	++localInitializedProcCount;

		glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC) getExtensionPtr( "glGetTexParameterIuivEXT" );
		if ( glGetTexParameterIuivEXT != 0 )	++localInitializedProcCount;

		glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC) getExtensionPtr( "glTexParameterIivEXT" );
		if ( glTexParameterIivEXT != 0 )	++localInitializedProcCount;

		glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC) getExtensionPtr( "glTexParameterIuivEXT" );
		if ( glTexParameterIuivEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_texture_integer )

	if ( isGL_EXT_texture_integer )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_integer                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_integer                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_integer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_integer                            : not detected." );
	}


	isGL_EXT_texture_lod_bias = isExtensionSupported("GL_EXT_texture_lod_bias");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_lod_bias )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_lod_bias                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_lod_bias                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_lod_bias") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_lod_bias                           : not detected." );
	}


	isGL_EXT_texture_mirror_clamp = isExtensionSupported("GL_EXT_texture_mirror_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_mirror_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_mirror_clamp                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_mirror_clamp                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_mirror_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_mirror_clamp                       : not detected." );
	}


	isGL_EXT_texture_object = isExtensionSupported("GL_EXT_texture_object");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_object ) // || isSEDEnable()
	{
		glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC) getExtensionPtr( "glAreTexturesResidentEXT" );
		if ( glAreTexturesResidentEXT != 0 )	++localInitializedProcCount;

		glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC) getExtensionPtr( "glBindTextureEXT" );
		if ( glBindTextureEXT != 0 )	++localInitializedProcCount;

		glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC) getExtensionPtr( "glDeleteTexturesEXT" );
		if ( glDeleteTexturesEXT != 0 )	++localInitializedProcCount;

		glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC) getExtensionPtr( "glGenTexturesEXT" );
		if ( glGenTexturesEXT != 0 )	++localInitializedProcCount;

		glIsTextureEXT = (PFNGLISTEXTUREEXTPROC) getExtensionPtr( "glIsTextureEXT" );
		if ( glIsTextureEXT != 0 )	++localInitializedProcCount;

		glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC) getExtensionPtr( "glPrioritizeTexturesEXT" );
		if ( glPrioritizeTexturesEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_texture_object )

	if ( isGL_EXT_texture_object )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_object                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_object                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_object                             : not detected." );
	}


	isGL_EXT_texture_perturb_normal = isExtensionSupported("GL_EXT_texture_perturb_normal");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_perturb_normal ) // || isSEDEnable()
	{
		glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC) getExtensionPtr( "glTextureNormalEXT" );
		if ( glTextureNormalEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_texture_perturb_normal )

	if ( isGL_EXT_texture_perturb_normal )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_perturb_normal                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_perturb_normal                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_perturb_normal") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_perturb_normal                     : not detected." );
	}


	isGL_EXT_texture_sRGB = isExtensionSupported("GL_EXT_texture_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_sRGB )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_sRGB                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_sRGB                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_sRGB                               : not detected." );
	}


	isGL_EXT_texture_sRGB_decode = isExtensionSupported("GL_EXT_texture_sRGB_decode");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_sRGB_decode )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_sRGB_decode                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_sRGB_decode                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_sRGB_decode") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_sRGB_decode                        : not detected." );
	}


	isGL_EXT_texture_shared_exponent = isExtensionSupported("GL_EXT_texture_shared_exponent");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_shared_exponent )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_shared_exponent                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_shared_exponent                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_shared_exponent") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_shared_exponent                    : not detected." );
	}


	isGL_EXT_texture_snorm = isExtensionSupported("GL_EXT_texture_snorm");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_snorm )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_snorm                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_snorm                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_snorm") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_snorm                              : not detected." );
	}


	isGL_EXT_texture_swizzle = isExtensionSupported("GL_EXT_texture_swizzle");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_texture_swizzle )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_texture_swizzle                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_texture_swizzle                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_texture_swizzle") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_texture_swizzle                            : not detected." );
	}


	isGL_EXT_timer_query = isExtensionSupported("GL_EXT_timer_query");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_timer_query ) // || isSEDEnable()
	{
		glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC) getExtensionPtr( "glGetQueryObjecti64vEXT" );
		if ( glGetQueryObjecti64vEXT != 0 )	++localInitializedProcCount;

		glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC) getExtensionPtr( "glGetQueryObjectui64vEXT" );
		if ( glGetQueryObjectui64vEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_timer_query )

	if ( isGL_EXT_timer_query )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_timer_query                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_timer_query                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_timer_query") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_timer_query                                : not detected." );
	}


	isGL_EXT_transform_feedback = isExtensionSupported("GL_EXT_transform_feedback");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_transform_feedback ) // || isSEDEnable()
	{
		glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC) getExtensionPtr( "glBeginTransformFeedbackEXT" );
		if ( glBeginTransformFeedbackEXT != 0 )	++localInitializedProcCount;

		glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC) getExtensionPtr( "glBindBufferBaseEXT" );
		if ( glBindBufferBaseEXT != 0 )	++localInitializedProcCount;

		glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC) getExtensionPtr( "glBindBufferOffsetEXT" );
		if ( glBindBufferOffsetEXT != 0 )	++localInitializedProcCount;

		glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC) getExtensionPtr( "glBindBufferRangeEXT" );
		if ( glBindBufferRangeEXT != 0 )	++localInitializedProcCount;

		glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC) getExtensionPtr( "glEndTransformFeedbackEXT" );
		if ( glEndTransformFeedbackEXT != 0 )	++localInitializedProcCount;

		glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) getExtensionPtr( "glGetTransformFeedbackVaryingEXT" );
		if ( glGetTransformFeedbackVaryingEXT != 0 )	++localInitializedProcCount;

		glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) getExtensionPtr( "glTransformFeedbackVaryingsEXT" );
		if ( glTransformFeedbackVaryingsEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_transform_feedback )

	if ( isGL_EXT_transform_feedback )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_transform_feedback                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_transform_feedback                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_transform_feedback") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_transform_feedback                         : not detected." );
	}


	isGL_EXT_vertex_array = isExtensionSupported("GL_EXT_vertex_array");

	localSupportedProcCount		= 9;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_vertex_array ) // || isSEDEnable()
	{
		glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC) getExtensionPtr( "glArrayElementEXT" );
		if ( glArrayElementEXT != 0 )	++localInitializedProcCount;

		glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC) getExtensionPtr( "glColorPointerEXT" );
		if ( glColorPointerEXT != 0 )	++localInitializedProcCount;

		glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC) getExtensionPtr( "glDrawArraysEXT" );
		if ( glDrawArraysEXT != 0 )	++localInitializedProcCount;

		glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC) getExtensionPtr( "glEdgeFlagPointerEXT" );
		if ( glEdgeFlagPointerEXT != 0 )	++localInitializedProcCount;

		glGetPointervEXT = (PFNGLGETPOINTERVEXTPROC) getExtensionPtr( "glGetPointervEXT" );
		if ( glGetPointervEXT != 0 )	++localInitializedProcCount;

		glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC) getExtensionPtr( "glIndexPointerEXT" );
		if ( glIndexPointerEXT != 0 )	++localInitializedProcCount;

		glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC) getExtensionPtr( "glNormalPointerEXT" );
		if ( glNormalPointerEXT != 0 )	++localInitializedProcCount;

		glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC) getExtensionPtr( "glTexCoordPointerEXT" );
		if ( glTexCoordPointerEXT != 0 )	++localInitializedProcCount;

		glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC) getExtensionPtr( "glVertexPointerEXT" );
		if ( glVertexPointerEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_vertex_array )

	if ( isGL_EXT_vertex_array )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_vertex_array                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_vertex_array                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_vertex_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_vertex_array                               : not detected." );
	}


	isGL_EXT_vertex_array_bgra = isExtensionSupported("GL_EXT_vertex_array_bgra");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_vertex_array_bgra )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_vertex_array_bgra                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_vertex_array_bgra                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_vertex_array_bgra") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_vertex_array_bgra                          : not detected." );
	}


	isGL_EXT_vertex_attrib_64bit = isExtensionSupported("GL_EXT_vertex_attrib_64bit");

	localSupportedProcCount		= 11;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_vertex_attrib_64bit ) // || isSEDEnable()
	{
		glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC) getExtensionPtr( "glGetVertexAttribLdvEXT" );
		if ( glGetVertexAttribLdvEXT != 0 )	++localInitializedProcCount;

		glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC) getExtensionPtr( "glVertexArrayVertexAttribLOffsetEXT" );
		if ( glVertexArrayVertexAttribLOffsetEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC) getExtensionPtr( "glVertexAttribL1dEXT" );
		if ( glVertexAttribL1dEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC) getExtensionPtr( "glVertexAttribL1dvEXT" );
		if ( glVertexAttribL1dvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC) getExtensionPtr( "glVertexAttribL2dEXT" );
		if ( glVertexAttribL2dEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC) getExtensionPtr( "glVertexAttribL2dvEXT" );
		if ( glVertexAttribL2dvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC) getExtensionPtr( "glVertexAttribL3dEXT" );
		if ( glVertexAttribL3dEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC) getExtensionPtr( "glVertexAttribL3dvEXT" );
		if ( glVertexAttribL3dvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC) getExtensionPtr( "glVertexAttribL4dEXT" );
		if ( glVertexAttribL4dEXT != 0 )	++localInitializedProcCount;

		glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC) getExtensionPtr( "glVertexAttribL4dvEXT" );
		if ( glVertexAttribL4dvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC) getExtensionPtr( "glVertexAttribLPointerEXT" );
		if ( glVertexAttribLPointerEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_vertex_attrib_64bit )

	if ( isGL_EXT_vertex_attrib_64bit )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_vertex_attrib_64bit                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_vertex_attrib_64bit                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_vertex_attrib_64bit") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_vertex_attrib_64bit                        : not detected." );
	}


	isGL_EXT_vertex_shader = isExtensionSupported("GL_EXT_vertex_shader");

	localSupportedProcCount		= 42;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_vertex_shader ) // || isSEDEnable()
	{
		glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC) getExtensionPtr( "glBeginVertexShaderEXT" );
		if ( glBeginVertexShaderEXT != 0 )	++localInitializedProcCount;

		glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC) getExtensionPtr( "glBindLightParameterEXT" );
		if ( glBindLightParameterEXT != 0 )	++localInitializedProcCount;

		glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC) getExtensionPtr( "glBindMaterialParameterEXT" );
		if ( glBindMaterialParameterEXT != 0 )	++localInitializedProcCount;

		glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC) getExtensionPtr( "glBindParameterEXT" );
		if ( glBindParameterEXT != 0 )	++localInitializedProcCount;

		glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC) getExtensionPtr( "glBindTexGenParameterEXT" );
		if ( glBindTexGenParameterEXT != 0 )	++localInitializedProcCount;

		glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) getExtensionPtr( "glBindTextureUnitParameterEXT" );
		if ( glBindTextureUnitParameterEXT != 0 )	++localInitializedProcCount;

		glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC) getExtensionPtr( "glBindVertexShaderEXT" );
		if ( glBindVertexShaderEXT != 0 )	++localInitializedProcCount;

		glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC) getExtensionPtr( "glDeleteVertexShaderEXT" );
		if ( glDeleteVertexShaderEXT != 0 )	++localInitializedProcCount;

		glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) getExtensionPtr( "glDisableVariantClientStateEXT" );
		if ( glDisableVariantClientStateEXT != 0 )	++localInitializedProcCount;

		glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) getExtensionPtr( "glEnableVariantClientStateEXT" );
		if ( glEnableVariantClientStateEXT != 0 )	++localInitializedProcCount;

		glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC) getExtensionPtr( "glEndVertexShaderEXT" );
		if ( glEndVertexShaderEXT != 0 )	++localInitializedProcCount;

		glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC) getExtensionPtr( "glExtractComponentEXT" );
		if ( glExtractComponentEXT != 0 )	++localInitializedProcCount;

		glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC) getExtensionPtr( "glGenSymbolsEXT" );
		if ( glGenSymbolsEXT != 0 )	++localInitializedProcCount;

		glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC) getExtensionPtr( "glGenVertexShadersEXT" );
		if ( glGenVertexShadersEXT != 0 )	++localInitializedProcCount;

		glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC) getExtensionPtr( "glGetInvariantBooleanvEXT" );
		if ( glGetInvariantBooleanvEXT != 0 )	++localInitializedProcCount;

		glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC) getExtensionPtr( "glGetInvariantFloatvEXT" );
		if ( glGetInvariantFloatvEXT != 0 )	++localInitializedProcCount;

		glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC) getExtensionPtr( "glGetInvariantIntegervEXT" );
		if ( glGetInvariantIntegervEXT != 0 )	++localInitializedProcCount;

		glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) getExtensionPtr( "glGetLocalConstantBooleanvEXT" );
		if ( glGetLocalConstantBooleanvEXT != 0 )	++localInitializedProcCount;

		glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC) getExtensionPtr( "glGetLocalConstantFloatvEXT" );
		if ( glGetLocalConstantFloatvEXT != 0 )	++localInitializedProcCount;

		glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) getExtensionPtr( "glGetLocalConstantIntegervEXT" );
		if ( glGetLocalConstantIntegervEXT != 0 )	++localInitializedProcCount;

		glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC) getExtensionPtr( "glGetVariantBooleanvEXT" );
		if ( glGetVariantBooleanvEXT != 0 )	++localInitializedProcCount;

		glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC) getExtensionPtr( "glGetVariantFloatvEXT" );
		if ( glGetVariantFloatvEXT != 0 )	++localInitializedProcCount;

		glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC) getExtensionPtr( "glGetVariantIntegervEXT" );
		if ( glGetVariantIntegervEXT != 0 )	++localInitializedProcCount;

		glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC) getExtensionPtr( "glGetVariantPointervEXT" );
		if ( glGetVariantPointervEXT != 0 )	++localInitializedProcCount;

		glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC) getExtensionPtr( "glInsertComponentEXT" );
		if ( glInsertComponentEXT != 0 )	++localInitializedProcCount;

		glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC) getExtensionPtr( "glIsVariantEnabledEXT" );
		if ( glIsVariantEnabledEXT != 0 )	++localInitializedProcCount;

		glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC) getExtensionPtr( "glSetInvariantEXT" );
		if ( glSetInvariantEXT != 0 )	++localInitializedProcCount;

		glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC) getExtensionPtr( "glSetLocalConstantEXT" );
		if ( glSetLocalConstantEXT != 0 )	++localInitializedProcCount;

		glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC) getExtensionPtr( "glShaderOp1EXT" );
		if ( glShaderOp1EXT != 0 )	++localInitializedProcCount;

		glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC) getExtensionPtr( "glShaderOp2EXT" );
		if ( glShaderOp2EXT != 0 )	++localInitializedProcCount;

		glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC) getExtensionPtr( "glShaderOp3EXT" );
		if ( glShaderOp3EXT != 0 )	++localInitializedProcCount;

		glSwizzleEXT = (PFNGLSWIZZLEEXTPROC) getExtensionPtr( "glSwizzleEXT" );
		if ( glSwizzleEXT != 0 )	++localInitializedProcCount;

		glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC) getExtensionPtr( "glVariantPointerEXT" );
		if ( glVariantPointerEXT != 0 )	++localInitializedProcCount;

		glVariantbvEXT = (PFNGLVARIANTBVEXTPROC) getExtensionPtr( "glVariantbvEXT" );
		if ( glVariantbvEXT != 0 )	++localInitializedProcCount;

		glVariantdvEXT = (PFNGLVARIANTDVEXTPROC) getExtensionPtr( "glVariantdvEXT" );
		if ( glVariantdvEXT != 0 )	++localInitializedProcCount;

		glVariantfvEXT = (PFNGLVARIANTFVEXTPROC) getExtensionPtr( "glVariantfvEXT" );
		if ( glVariantfvEXT != 0 )	++localInitializedProcCount;

		glVariantivEXT = (PFNGLVARIANTIVEXTPROC) getExtensionPtr( "glVariantivEXT" );
		if ( glVariantivEXT != 0 )	++localInitializedProcCount;

		glVariantsvEXT = (PFNGLVARIANTSVEXTPROC) getExtensionPtr( "glVariantsvEXT" );
		if ( glVariantsvEXT != 0 )	++localInitializedProcCount;

		glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC) getExtensionPtr( "glVariantubvEXT" );
		if ( glVariantubvEXT != 0 )	++localInitializedProcCount;

		glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC) getExtensionPtr( "glVariantuivEXT" );
		if ( glVariantuivEXT != 0 )	++localInitializedProcCount;

		glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC) getExtensionPtr( "glVariantusvEXT" );
		if ( glVariantusvEXT != 0 )	++localInitializedProcCount;

		glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC) getExtensionPtr( "glWriteMaskEXT" );
		if ( glWriteMaskEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_vertex_shader )

	if ( isGL_EXT_vertex_shader )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_vertex_shader                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_vertex_shader                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_vertex_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_vertex_shader                              : not detected." );
	}


	isGL_EXT_vertex_weighting = isExtensionSupported("GL_EXT_vertex_weighting");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_vertex_weighting ) // || isSEDEnable()
	{
		glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC) getExtensionPtr( "glVertexWeightPointerEXT" );
		if ( glVertexWeightPointerEXT != 0 )	++localInitializedProcCount;

		glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC) getExtensionPtr( "glVertexWeightfEXT" );
		if ( glVertexWeightfEXT != 0 )	++localInitializedProcCount;

		glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC) getExtensionPtr( "glVertexWeightfvEXT" );
		if ( glVertexWeightfvEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_vertex_weighting )

	if ( isGL_EXT_vertex_weighting )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_vertex_weighting                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_vertex_weighting                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_vertex_weighting") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_vertex_weighting                           : not detected." );
	}


	isGL_EXT_x11_sync_object = isExtensionSupported("GL_EXT_x11_sync_object");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_EXT_x11_sync_object ) // || isSEDEnable()
	{
		glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC) getExtensionPtr( "glImportSyncEXT" );
		if ( glImportSyncEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_EXT_x11_sync_object )

	if ( isGL_EXT_x11_sync_object )
	{
		std::stringstream strStream;
		strStream << "GL_EXT_x11_sync_object                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_EXT_x11_sync_object                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_EXT_x11_sync_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_EXT_x11_sync_object                            : not detected." );
	}


} // initializeGL_EXT_x11_sync_object()


void OpenGLExtensionsGen::initializeGL_FfdMaskSGIX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_FfdMaskSGIX = isExtensionSupported("GL_FfdMaskSGIX");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_FfdMaskSGIX )
	{
		std::stringstream strStream;
		strStream << "GL_FfdMaskSGIX                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_FfdMaskSGIX                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_FfdMaskSGIX") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_FfdMaskSGIX                                    : not detected." );
	}


} // initializeGL_FfdMaskSGIX()


void OpenGLExtensionsGen::initializeGL_GREMEDY()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_GREMEDY_frame_terminator = isExtensionSupported("GL_GREMEDY_frame_terminator");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_GREMEDY_frame_terminator ) // || isSEDEnable()
	{
		glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC) getExtensionPtr( "glFrameTerminatorGREMEDY" );
		if ( glFrameTerminatorGREMEDY != 0 )	++localInitializedProcCount;

	} // if ( isGL_GREMEDY_frame_terminator )

	if ( isGL_GREMEDY_frame_terminator )
	{
		std::stringstream strStream;
		strStream << "GL_GREMEDY_frame_terminator                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_GREMEDY_frame_terminator                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_GREMEDY_frame_terminator") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_GREMEDY_frame_terminator                       : not detected." );
	}


	isGL_GREMEDY_string_marker = isExtensionSupported("GL_GREMEDY_string_marker");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_GREMEDY_string_marker ) // || isSEDEnable()
	{
		glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC) getExtensionPtr( "glStringMarkerGREMEDY" );
		if ( glStringMarkerGREMEDY != 0 )	++localInitializedProcCount;

	} // if ( isGL_GREMEDY_string_marker )

	if ( isGL_GREMEDY_string_marker )
	{
		std::stringstream strStream;
		strStream << "GL_GREMEDY_string_marker                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_GREMEDY_string_marker                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_GREMEDY_string_marker") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_GREMEDY_string_marker                          : not detected." );
	}


} // initializeGL_GREMEDY_string_marker()


void OpenGLExtensionsGen::initializeGL_HP()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_HP_convolution_border_modes = isExtensionSupported("GL_HP_convolution_border_modes");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_HP_convolution_border_modes )
	{
		std::stringstream strStream;
		strStream << "GL_HP_convolution_border_modes                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_HP_convolution_border_modes                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_HP_convolution_border_modes") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_HP_convolution_border_modes                    : not detected." );
	}


	isGL_HP_image_transform = isExtensionSupported("GL_HP_image_transform");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_HP_image_transform ) // || isSEDEnable()
	{
		glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) getExtensionPtr( "glGetImageTransformParameterfvHP" );
		if ( glGetImageTransformParameterfvHP != 0 )	++localInitializedProcCount;

		glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) getExtensionPtr( "glGetImageTransformParameterivHP" );
		if ( glGetImageTransformParameterivHP != 0 )	++localInitializedProcCount;

		glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC) getExtensionPtr( "glImageTransformParameterfHP" );
		if ( glImageTransformParameterfHP != 0 )	++localInitializedProcCount;

		glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) getExtensionPtr( "glImageTransformParameterfvHP" );
		if ( glImageTransformParameterfvHP != 0 )	++localInitializedProcCount;

		glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC) getExtensionPtr( "glImageTransformParameteriHP" );
		if ( glImageTransformParameteriHP != 0 )	++localInitializedProcCount;

		glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) getExtensionPtr( "glImageTransformParameterivHP" );
		if ( glImageTransformParameterivHP != 0 )	++localInitializedProcCount;

	} // if ( isGL_HP_image_transform )

	if ( isGL_HP_image_transform )
	{
		std::stringstream strStream;
		strStream << "GL_HP_image_transform                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_HP_image_transform                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_HP_image_transform") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_HP_image_transform                             : not detected." );
	}


	isGL_HP_occlusion_test = isExtensionSupported("GL_HP_occlusion_test");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_HP_occlusion_test )
	{
		std::stringstream strStream;
		strStream << "GL_HP_occlusion_test                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_HP_occlusion_test                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_HP_occlusion_test") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_HP_occlusion_test                              : not detected." );
	}


	isGL_HP_texture_lighting = isExtensionSupported("GL_HP_texture_lighting");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_HP_texture_lighting )
	{
		std::stringstream strStream;
		strStream << "GL_HP_texture_lighting                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_HP_texture_lighting                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_HP_texture_lighting") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_HP_texture_lighting                            : not detected." );
	}


} // initializeGL_HP_texture_lighting()


void OpenGLExtensionsGen::initializeGL_IBM()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_IBM_cull_vertex = isExtensionSupported("GL_IBM_cull_vertex");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_IBM_cull_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_IBM_cull_vertex                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_IBM_cull_vertex                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_IBM_cull_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_IBM_cull_vertex                                : not detected." );
	}


	isGL_IBM_multimode_draw_arrays = isExtensionSupported("GL_IBM_multimode_draw_arrays");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_IBM_multimode_draw_arrays ) // || isSEDEnable()
	{
		glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC) getExtensionPtr( "glMultiModeDrawArraysIBM" );
		if ( glMultiModeDrawArraysIBM != 0 )	++localInitializedProcCount;

		glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC) getExtensionPtr( "glMultiModeDrawElementsIBM" );
		if ( glMultiModeDrawElementsIBM != 0 )	++localInitializedProcCount;

	} // if ( isGL_IBM_multimode_draw_arrays )

	if ( isGL_IBM_multimode_draw_arrays )
	{
		std::stringstream strStream;
		strStream << "GL_IBM_multimode_draw_arrays                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_IBM_multimode_draw_arrays                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_IBM_multimode_draw_arrays") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_IBM_multimode_draw_arrays                      : not detected." );
	}


	isGL_IBM_rasterpos_clip = isExtensionSupported("GL_IBM_rasterpos_clip");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_IBM_rasterpos_clip )
	{
		std::stringstream strStream;
		strStream << "GL_IBM_rasterpos_clip                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_IBM_rasterpos_clip                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_IBM_rasterpos_clip") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_IBM_rasterpos_clip                             : not detected." );
	}


	isGL_IBM_texture_mirrored_repeat = isExtensionSupported("GL_IBM_texture_mirrored_repeat");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_IBM_texture_mirrored_repeat )
	{
		std::stringstream strStream;
		strStream << "GL_IBM_texture_mirrored_repeat                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_IBM_texture_mirrored_repeat                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_IBM_texture_mirrored_repeat") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_IBM_texture_mirrored_repeat                    : not detected." );
	}


	isGL_IBM_vertex_array_lists = isExtensionSupported("GL_IBM_vertex_array_lists");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isGL_IBM_vertex_array_lists ) // || isSEDEnable()
	{
		glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC) getExtensionPtr( "glColorPointerListIBM" );
		if ( glColorPointerListIBM != 0 )	++localInitializedProcCount;

		glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC) getExtensionPtr( "glEdgeFlagPointerListIBM" );
		if ( glEdgeFlagPointerListIBM != 0 )	++localInitializedProcCount;

		glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC) getExtensionPtr( "glFogCoordPointerListIBM" );
		if ( glFogCoordPointerListIBM != 0 )	++localInitializedProcCount;

		glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC) getExtensionPtr( "glIndexPointerListIBM" );
		if ( glIndexPointerListIBM != 0 )	++localInitializedProcCount;

		glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC) getExtensionPtr( "glNormalPointerListIBM" );
		if ( glNormalPointerListIBM != 0 )	++localInitializedProcCount;

		glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) getExtensionPtr( "glSecondaryColorPointerListIBM" );
		if ( glSecondaryColorPointerListIBM != 0 )	++localInitializedProcCount;

		glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC) getExtensionPtr( "glTexCoordPointerListIBM" );
		if ( glTexCoordPointerListIBM != 0 )	++localInitializedProcCount;

		glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC) getExtensionPtr( "glVertexPointerListIBM" );
		if ( glVertexPointerListIBM != 0 )	++localInitializedProcCount;

	} // if ( isGL_IBM_vertex_array_lists )

	if ( isGL_IBM_vertex_array_lists )
	{
		std::stringstream strStream;
		strStream << "GL_IBM_vertex_array_lists                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_IBM_vertex_array_lists                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_IBM_vertex_array_lists") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_IBM_vertex_array_lists                         : not detected." );
	}


} // initializeGL_IBM_vertex_array_lists()


void OpenGLExtensionsGen::initializeGL_INGR()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_INGR_blend_func_separate = isExtensionSupported("GL_INGR_blend_func_separate");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_INGR_blend_func_separate ) // || isSEDEnable()
	{
		glBlendFuncSeparateINGR = (PFNGLBLENDFUNCSEPARATEINGRPROC) getExtensionPtr( "glBlendFuncSeparateINGR" );
		if ( glBlendFuncSeparateINGR != 0 )	++localInitializedProcCount;

	} // if ( isGL_INGR_blend_func_separate )

	if ( isGL_INGR_blend_func_separate )
	{
		std::stringstream strStream;
		strStream << "GL_INGR_blend_func_separate                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INGR_blend_func_separate                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INGR_blend_func_separate") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INGR_blend_func_separate                       : not detected." );
	}


	isGL_INGR_color_clamp = isExtensionSupported("GL_INGR_color_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_INGR_color_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_INGR_color_clamp                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INGR_color_clamp                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INGR_color_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INGR_color_clamp                               : not detected." );
	}


	isGL_INGR_interlace_read = isExtensionSupported("GL_INGR_interlace_read");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_INGR_interlace_read )
	{
		std::stringstream strStream;
		strStream << "GL_INGR_interlace_read                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INGR_interlace_read                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INGR_interlace_read") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INGR_interlace_read                            : not detected." );
	}


	isGL_INGR_palette_buffer = isExtensionSupported("GL_INGR_palette_buffer");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_INGR_palette_buffer )
	{
		std::stringstream strStream;
		strStream << "GL_INGR_palette_buffer                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INGR_palette_buffer                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INGR_palette_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INGR_palette_buffer                            : not detected." );
	}


} // initializeGL_INGR_palette_buffer()


void OpenGLExtensionsGen::initializeGL_INTEL()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_INTEL_map_texture = isExtensionSupported("GL_INTEL_map_texture");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_INTEL_map_texture ) // || isSEDEnable()
	{
		glMapTexture2DINTEL = (PFNGLMAPTEXTURE2DINTELPROC) getExtensionPtr( "glMapTexture2DINTEL" );
		if ( glMapTexture2DINTEL != 0 )	++localInitializedProcCount;

		glSyncTextureINTEL = (PFNGLSYNCTEXTUREINTELPROC) getExtensionPtr( "glSyncTextureINTEL" );
		if ( glSyncTextureINTEL != 0 )	++localInitializedProcCount;

		glUnmapTexture2DINTEL = (PFNGLUNMAPTEXTURE2DINTELPROC) getExtensionPtr( "glUnmapTexture2DINTEL" );
		if ( glUnmapTexture2DINTEL != 0 )	++localInitializedProcCount;

	} // if ( isGL_INTEL_map_texture )

	if ( isGL_INTEL_map_texture )
	{
		std::stringstream strStream;
		strStream << "GL_INTEL_map_texture                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INTEL_map_texture                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INTEL_map_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INTEL_map_texture                              : not detected." );
	}


	isGL_INTEL_parallel_arrays = isExtensionSupported("GL_INTEL_parallel_arrays");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_INTEL_parallel_arrays ) // || isSEDEnable()
	{
		glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC) getExtensionPtr( "glColorPointervINTEL" );
		if ( glColorPointervINTEL != 0 )	++localInitializedProcCount;

		glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC) getExtensionPtr( "glNormalPointervINTEL" );
		if ( glNormalPointervINTEL != 0 )	++localInitializedProcCount;

		glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC) getExtensionPtr( "glTexCoordPointervINTEL" );
		if ( glTexCoordPointervINTEL != 0 )	++localInitializedProcCount;

		glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC) getExtensionPtr( "glVertexPointervINTEL" );
		if ( glVertexPointervINTEL != 0 )	++localInitializedProcCount;

	} // if ( isGL_INTEL_parallel_arrays )

	if ( isGL_INTEL_parallel_arrays )
	{
		std::stringstream strStream;
		strStream << "GL_INTEL_parallel_arrays                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INTEL_parallel_arrays                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INTEL_parallel_arrays") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INTEL_parallel_arrays                          : not detected." );
	}


	isGL_INTEL_texture_scissor = isExtensionSupported("GL_INTEL_texture_scissor");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_INTEL_texture_scissor )
	{
		std::stringstream strStream;
		strStream << "GL_INTEL_texture_scissor                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_INTEL_texture_scissor                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_INTEL_texture_scissor") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_INTEL_texture_scissor                          : not detected." );
	}


} // initializeGL_INTEL_texture_scissor()


void OpenGLExtensionsGen::initializeGL_KHR()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_KHR_debug = isExtensionSupported("GL_KHR_debug");

	localSupportedProcCount		= 10;
	localInitializedProcCount	= 0;

	if ( isGL_KHR_debug ) // || isSEDEnable()
	{
		glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC) getExtensionPtr( "glDebugMessageCallback" );
		if ( glDebugMessageCallback != 0 )	++localInitializedProcCount;

		glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC) getExtensionPtr( "glDebugMessageControl" );
		if ( glDebugMessageControl != 0 )	++localInitializedProcCount;

		glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC) getExtensionPtr( "glDebugMessageInsert" );
		if ( glDebugMessageInsert != 0 )	++localInitializedProcCount;

		glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC) getExtensionPtr( "glGetDebugMessageLog" );
		if ( glGetDebugMessageLog != 0 )	++localInitializedProcCount;

		glGetObjectLabel = (PFNGLGETOBJECTLABELPROC) getExtensionPtr( "glGetObjectLabel" );
		if ( glGetObjectLabel != 0 )	++localInitializedProcCount;

		glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC) getExtensionPtr( "glGetObjectPtrLabel" );
		if ( glGetObjectPtrLabel != 0 )	++localInitializedProcCount;

		glObjectLabel = (PFNGLOBJECTLABELPROC) getExtensionPtr( "glObjectLabel" );
		if ( glObjectLabel != 0 )	++localInitializedProcCount;

		glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC) getExtensionPtr( "glObjectPtrLabel" );
		if ( glObjectPtrLabel != 0 )	++localInitializedProcCount;

		glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC) getExtensionPtr( "glPopDebugGroup" );
		if ( glPopDebugGroup != 0 )	++localInitializedProcCount;

		glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC) getExtensionPtr( "glPushDebugGroup" );
		if ( glPushDebugGroup != 0 )	++localInitializedProcCount;

	} // if ( isGL_KHR_debug )

	if ( isGL_KHR_debug )
	{
		std::stringstream strStream;
		strStream << "GL_KHR_debug                                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_KHR_debug                                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_KHR_debug") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_KHR_debug                                      : not detected." );
	}


	isGL_KHR_texture_compression_astc_ldr = isExtensionSupported("GL_KHR_texture_compression_astc_ldr");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_KHR_texture_compression_astc_ldr )
	{
		std::stringstream strStream;
		strStream << "GL_KHR_texture_compression_astc_ldr               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_KHR_texture_compression_astc_ldr               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_KHR_texture_compression_astc_ldr") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_KHR_texture_compression_astc_ldr               : not detected." );
	}


} // initializeGL_KHR_texture_compression_astc_ldr()


void OpenGLExtensionsGen::initializeGL_MESA()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_MESA_pack_invert = isExtensionSupported("GL_MESA_pack_invert");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_MESA_pack_invert )
	{
		std::stringstream strStream;
		strStream << "GL_MESA_pack_invert                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_MESA_pack_invert                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_MESA_pack_invert") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_MESA_pack_invert                               : not detected." );
	}


	isGL_MESA_resize_buffers = isExtensionSupported("GL_MESA_resize_buffers");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_MESA_resize_buffers ) // || isSEDEnable()
	{
		glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC) getExtensionPtr( "glResizeBuffersMESA" );
		if ( glResizeBuffersMESA != 0 )	++localInitializedProcCount;

	} // if ( isGL_MESA_resize_buffers )

	if ( isGL_MESA_resize_buffers )
	{
		std::stringstream strStream;
		strStream << "GL_MESA_resize_buffers                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_MESA_resize_buffers                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_MESA_resize_buffers") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_MESA_resize_buffers                            : not detected." );
	}


	isGL_MESA_window_pos = isExtensionSupported("GL_MESA_window_pos");

	localSupportedProcCount		= 24;
	localInitializedProcCount	= 0;

	if ( isGL_MESA_window_pos ) // || isSEDEnable()
	{
		glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC) getExtensionPtr( "glWindowPos2dMESA" );
		if ( glWindowPos2dMESA != 0 )	++localInitializedProcCount;

		glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC) getExtensionPtr( "glWindowPos2dvMESA" );
		if ( glWindowPos2dvMESA != 0 )	++localInitializedProcCount;

		glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC) getExtensionPtr( "glWindowPos2fMESA" );
		if ( glWindowPos2fMESA != 0 )	++localInitializedProcCount;

		glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC) getExtensionPtr( "glWindowPos2fvMESA" );
		if ( glWindowPos2fvMESA != 0 )	++localInitializedProcCount;

		glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC) getExtensionPtr( "glWindowPos2iMESA" );
		if ( glWindowPos2iMESA != 0 )	++localInitializedProcCount;

		glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC) getExtensionPtr( "glWindowPos2ivMESA" );
		if ( glWindowPos2ivMESA != 0 )	++localInitializedProcCount;

		glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC) getExtensionPtr( "glWindowPos2sMESA" );
		if ( glWindowPos2sMESA != 0 )	++localInitializedProcCount;

		glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC) getExtensionPtr( "glWindowPos2svMESA" );
		if ( glWindowPos2svMESA != 0 )	++localInitializedProcCount;

		glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC) getExtensionPtr( "glWindowPos3dMESA" );
		if ( glWindowPos3dMESA != 0 )	++localInitializedProcCount;

		glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC) getExtensionPtr( "glWindowPos3dvMESA" );
		if ( glWindowPos3dvMESA != 0 )	++localInitializedProcCount;

		glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC) getExtensionPtr( "glWindowPos3fMESA" );
		if ( glWindowPos3fMESA != 0 )	++localInitializedProcCount;

		glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC) getExtensionPtr( "glWindowPos3fvMESA" );
		if ( glWindowPos3fvMESA != 0 )	++localInitializedProcCount;

		glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC) getExtensionPtr( "glWindowPos3iMESA" );
		if ( glWindowPos3iMESA != 0 )	++localInitializedProcCount;

		glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC) getExtensionPtr( "glWindowPos3ivMESA" );
		if ( glWindowPos3ivMESA != 0 )	++localInitializedProcCount;

		glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC) getExtensionPtr( "glWindowPos3sMESA" );
		if ( glWindowPos3sMESA != 0 )	++localInitializedProcCount;

		glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC) getExtensionPtr( "glWindowPos3svMESA" );
		if ( glWindowPos3svMESA != 0 )	++localInitializedProcCount;

		glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC) getExtensionPtr( "glWindowPos4dMESA" );
		if ( glWindowPos4dMESA != 0 )	++localInitializedProcCount;

		glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC) getExtensionPtr( "glWindowPos4dvMESA" );
		if ( glWindowPos4dvMESA != 0 )	++localInitializedProcCount;

		glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC) getExtensionPtr( "glWindowPos4fMESA" );
		if ( glWindowPos4fMESA != 0 )	++localInitializedProcCount;

		glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC) getExtensionPtr( "glWindowPos4fvMESA" );
		if ( glWindowPos4fvMESA != 0 )	++localInitializedProcCount;

		glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC) getExtensionPtr( "glWindowPos4iMESA" );
		if ( glWindowPos4iMESA != 0 )	++localInitializedProcCount;

		glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC) getExtensionPtr( "glWindowPos4ivMESA" );
		if ( glWindowPos4ivMESA != 0 )	++localInitializedProcCount;

		glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC) getExtensionPtr( "glWindowPos4sMESA" );
		if ( glWindowPos4sMESA != 0 )	++localInitializedProcCount;

		glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC) getExtensionPtr( "glWindowPos4svMESA" );
		if ( glWindowPos4svMESA != 0 )	++localInitializedProcCount;

	} // if ( isGL_MESA_window_pos )

	if ( isGL_MESA_window_pos )
	{
		std::stringstream strStream;
		strStream << "GL_MESA_window_pos                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_MESA_window_pos                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_MESA_window_pos") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_MESA_window_pos                                : not detected." );
	}


	isGL_MESA_ycbcr_texture = isExtensionSupported("GL_MESA_ycbcr_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_MESA_ycbcr_texture )
	{
		std::stringstream strStream;
		strStream << "GL_MESA_ycbcr_texture                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_MESA_ycbcr_texture                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_MESA_ycbcr_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_MESA_ycbcr_texture                             : not detected." );
	}


} // initializeGL_MESA_ycbcr_texture()


void OpenGLExtensionsGen::initializeGL_MESAX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_MESAX_texture_stack = isExtensionSupported("GL_MESAX_texture_stack");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_MESAX_texture_stack )
	{
		std::stringstream strStream;
		strStream << "GL_MESAX_texture_stack                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_MESAX_texture_stack                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_MESAX_texture_stack") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_MESAX_texture_stack                            : not detected." );
	}


} // initializeGL_MESAX_texture_stack()


void OpenGLExtensionsGen::initializeGL_NV()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_NV_bindless_texture = isExtensionSupported("GL_NV_bindless_texture");

	localSupportedProcCount		= 13;
	localInitializedProcCount	= 0;

	if ( isGL_NV_bindless_texture ) // || isSEDEnable()
	{
		glGetImageHandleNV = (PFNGLGETIMAGEHANDLENVPROC) getExtensionPtr( "glGetImageHandleNV" );
		if ( glGetImageHandleNV != 0 )	++localInitializedProcCount;

		glGetTextureHandleNV = (PFNGLGETTEXTUREHANDLENVPROC) getExtensionPtr( "glGetTextureHandleNV" );
		if ( glGetTextureHandleNV != 0 )	++localInitializedProcCount;

		glGetTextureSamplerHandleNV = (PFNGLGETTEXTURESAMPLERHANDLENVPROC) getExtensionPtr( "glGetTextureSamplerHandleNV" );
		if ( glGetTextureSamplerHandleNV != 0 )	++localInitializedProcCount;

		glIsImageHandleResidentNV = (PFNGLISIMAGEHANDLERESIDENTNVPROC) getExtensionPtr( "glIsImageHandleResidentNV" );
		if ( glIsImageHandleResidentNV != 0 )	++localInitializedProcCount;

		glIsTextureHandleResidentNV = (PFNGLISTEXTUREHANDLERESIDENTNVPROC) getExtensionPtr( "glIsTextureHandleResidentNV" );
		if ( glIsTextureHandleResidentNV != 0 )	++localInitializedProcCount;

		glMakeImageHandleNonResidentNV = (PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC) getExtensionPtr( "glMakeImageHandleNonResidentNV" );
		if ( glMakeImageHandleNonResidentNV != 0 )	++localInitializedProcCount;

		glMakeImageHandleResidentNV = (PFNGLMAKEIMAGEHANDLERESIDENTNVPROC) getExtensionPtr( "glMakeImageHandleResidentNV" );
		if ( glMakeImageHandleResidentNV != 0 )	++localInitializedProcCount;

		glMakeTextureHandleNonResidentNV = (PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC) getExtensionPtr( "glMakeTextureHandleNonResidentNV" );
		if ( glMakeTextureHandleNonResidentNV != 0 )	++localInitializedProcCount;

		glMakeTextureHandleResidentNV = (PFNGLMAKETEXTUREHANDLERESIDENTNVPROC) getExtensionPtr( "glMakeTextureHandleResidentNV" );
		if ( glMakeTextureHandleResidentNV != 0 )	++localInitializedProcCount;

		glProgramUniformHandleui64NV = (PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC) getExtensionPtr( "glProgramUniformHandleui64NV" );
		if ( glProgramUniformHandleui64NV != 0 )	++localInitializedProcCount;

		glProgramUniformHandleui64vNV = (PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC) getExtensionPtr( "glProgramUniformHandleui64vNV" );
		if ( glProgramUniformHandleui64vNV != 0 )	++localInitializedProcCount;

		glUniformHandleui64NV = (PFNGLUNIFORMHANDLEUI64NVPROC) getExtensionPtr( "glUniformHandleui64NV" );
		if ( glUniformHandleui64NV != 0 )	++localInitializedProcCount;

		glUniformHandleui64vNV = (PFNGLUNIFORMHANDLEUI64VNVPROC) getExtensionPtr( "glUniformHandleui64vNV" );
		if ( glUniformHandleui64vNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_bindless_texture )

	if ( isGL_NV_bindless_texture )
	{
		std::stringstream strStream;
		strStream << "GL_NV_bindless_texture                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_bindless_texture                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_bindless_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_bindless_texture                            : not detected." );
	}


	isGL_NV_blend_square = isExtensionSupported("GL_NV_blend_square");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_blend_square )
	{
		std::stringstream strStream;
		strStream << "GL_NV_blend_square                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_blend_square                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_blend_square") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_blend_square                                : not detected." );
	}


	isGL_NV_compute_program5 = isExtensionSupported("GL_NV_compute_program5");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_compute_program5 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_compute_program5                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_compute_program5                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_compute_program5") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_compute_program5                            : not detected." );
	}


	isGL_NV_conditional_render = isExtensionSupported("GL_NV_conditional_render");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_conditional_render ) // || isSEDEnable()
	{
		glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC) getExtensionPtr( "glBeginConditionalRenderNV" );
		if ( glBeginConditionalRenderNV != 0 )	++localInitializedProcCount;

		glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC) getExtensionPtr( "glEndConditionalRenderNV" );
		if ( glEndConditionalRenderNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_conditional_render )

	if ( isGL_NV_conditional_render )
	{
		std::stringstream strStream;
		strStream << "GL_NV_conditional_render                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_conditional_render                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_conditional_render") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_conditional_render                          : not detected." );
	}


	isGL_NV_copy_depth_to_color = isExtensionSupported("GL_NV_copy_depth_to_color");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_copy_depth_to_color )
	{
		std::stringstream strStream;
		strStream << "GL_NV_copy_depth_to_color                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_copy_depth_to_color                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_copy_depth_to_color") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_copy_depth_to_color                         : not detected." );
	}


	isGL_NV_copy_image = isExtensionSupported("GL_NV_copy_image");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_NV_copy_image ) // || isSEDEnable()
	{
		glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC) getExtensionPtr( "glCopyImageSubDataNV" );
		if ( glCopyImageSubDataNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_copy_image )

	if ( isGL_NV_copy_image )
	{
		std::stringstream strStream;
		strStream << "GL_NV_copy_image                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_copy_image                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_copy_image") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_copy_image                                  : not detected." );
	}


	isGL_NV_deep_texture3D = isExtensionSupported("GL_NV_deep_texture3D");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_deep_texture3D )
	{
		std::stringstream strStream;
		strStream << "GL_NV_deep_texture3D                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_deep_texture3D                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_deep_texture3D") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_deep_texture3D                              : not detected." );
	}


	isGL_NV_depth_buffer_float = isExtensionSupported("GL_NV_depth_buffer_float");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_NV_depth_buffer_float ) // || isSEDEnable()
	{
		glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC) getExtensionPtr( "glClearDepthdNV" );
		if ( glClearDepthdNV != 0 )	++localInitializedProcCount;

		glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC) getExtensionPtr( "glDepthBoundsdNV" );
		if ( glDepthBoundsdNV != 0 )	++localInitializedProcCount;

		glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC) getExtensionPtr( "glDepthRangedNV" );
		if ( glDepthRangedNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_depth_buffer_float )

	if ( isGL_NV_depth_buffer_float )
	{
		std::stringstream strStream;
		strStream << "GL_NV_depth_buffer_float                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_depth_buffer_float                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_depth_buffer_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_depth_buffer_float                          : not detected." );
	}


	isGL_NV_depth_clamp = isExtensionSupported("GL_NV_depth_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_depth_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_NV_depth_clamp                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_depth_clamp                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_depth_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_depth_clamp                                 : not detected." );
	}


	isGL_NV_draw_texture = isExtensionSupported("GL_NV_draw_texture");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_NV_draw_texture ) // || isSEDEnable()
	{
		glDrawTextureNV = (PFNGLDRAWTEXTURENVPROC) getExtensionPtr( "glDrawTextureNV" );
		if ( glDrawTextureNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_draw_texture )

	if ( isGL_NV_draw_texture )
	{
		std::stringstream strStream;
		strStream << "GL_NV_draw_texture                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_draw_texture                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_draw_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_draw_texture                                : not detected." );
	}


	isGL_NV_evaluators = isExtensionSupported("GL_NV_evaluators");

	localSupportedProcCount		= 9;
	localInitializedProcCount	= 0;

	if ( isGL_NV_evaluators ) // || isSEDEnable()
	{
		glEvalMapsNV = (PFNGLEVALMAPSNVPROC) getExtensionPtr( "glEvalMapsNV" );
		if ( glEvalMapsNV != 0 )	++localInitializedProcCount;

		glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC) getExtensionPtr( "glGetMapAttribParameterfvNV" );
		if ( glGetMapAttribParameterfvNV != 0 )	++localInitializedProcCount;

		glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC) getExtensionPtr( "glGetMapAttribParameterivNV" );
		if ( glGetMapAttribParameterivNV != 0 )	++localInitializedProcCount;

		glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC) getExtensionPtr( "glGetMapControlPointsNV" );
		if ( glGetMapControlPointsNV != 0 )	++localInitializedProcCount;

		glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC) getExtensionPtr( "glGetMapParameterfvNV" );
		if ( glGetMapParameterfvNV != 0 )	++localInitializedProcCount;

		glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC) getExtensionPtr( "glGetMapParameterivNV" );
		if ( glGetMapParameterivNV != 0 )	++localInitializedProcCount;

		glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC) getExtensionPtr( "glMapControlPointsNV" );
		if ( glMapControlPointsNV != 0 )	++localInitializedProcCount;

		glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC) getExtensionPtr( "glMapParameterfvNV" );
		if ( glMapParameterfvNV != 0 )	++localInitializedProcCount;

		glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC) getExtensionPtr( "glMapParameterivNV" );
		if ( glMapParameterivNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_evaluators )

	if ( isGL_NV_evaluators )
	{
		std::stringstream strStream;
		strStream << "GL_NV_evaluators                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_evaluators                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_evaluators") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_evaluators                                  : not detected." );
	}


	isGL_NV_explicit_multisample = isExtensionSupported("GL_NV_explicit_multisample");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_NV_explicit_multisample ) // || isSEDEnable()
	{
		glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC) getExtensionPtr( "glGetMultisamplefvNV" );
		if ( glGetMultisamplefvNV != 0 )	++localInitializedProcCount;

		glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC) getExtensionPtr( "glSampleMaskIndexedNV" );
		if ( glSampleMaskIndexedNV != 0 )	++localInitializedProcCount;

		glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC) getExtensionPtr( "glTexRenderbufferNV" );
		if ( glTexRenderbufferNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_explicit_multisample )

	if ( isGL_NV_explicit_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_NV_explicit_multisample                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_explicit_multisample                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_explicit_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_explicit_multisample                        : not detected." );
	}


	isGL_NV_fence = isExtensionSupported("GL_NV_fence");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_NV_fence ) // || isSEDEnable()
	{
		glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC) getExtensionPtr( "glDeleteFencesNV" );
		if ( glDeleteFencesNV != 0 )	++localInitializedProcCount;

		glFinishFenceNV = (PFNGLFINISHFENCENVPROC) getExtensionPtr( "glFinishFenceNV" );
		if ( glFinishFenceNV != 0 )	++localInitializedProcCount;

		glGenFencesNV = (PFNGLGENFENCESNVPROC) getExtensionPtr( "glGenFencesNV" );
		if ( glGenFencesNV != 0 )	++localInitializedProcCount;

		glGetFenceivNV = (PFNGLGETFENCEIVNVPROC) getExtensionPtr( "glGetFenceivNV" );
		if ( glGetFenceivNV != 0 )	++localInitializedProcCount;

		glIsFenceNV = (PFNGLISFENCENVPROC) getExtensionPtr( "glIsFenceNV" );
		if ( glIsFenceNV != 0 )	++localInitializedProcCount;

		glSetFenceNV = (PFNGLSETFENCENVPROC) getExtensionPtr( "glSetFenceNV" );
		if ( glSetFenceNV != 0 )	++localInitializedProcCount;

		glTestFenceNV = (PFNGLTESTFENCENVPROC) getExtensionPtr( "glTestFenceNV" );
		if ( glTestFenceNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_fence )

	if ( isGL_NV_fence )
	{
		std::stringstream strStream;
		strStream << "GL_NV_fence                                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_fence                                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_fence") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_fence                                       : not detected." );
	}


	isGL_NV_float_buffer = isExtensionSupported("GL_NV_float_buffer");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_float_buffer )
	{
		std::stringstream strStream;
		strStream << "GL_NV_float_buffer                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_float_buffer                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_float_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_float_buffer                                : not detected." );
	}


	isGL_NV_fog_distance = isExtensionSupported("GL_NV_fog_distance");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_fog_distance )
	{
		std::stringstream strStream;
		strStream << "GL_NV_fog_distance                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_fog_distance                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_fog_distance") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_fog_distance                                : not detected." );
	}


	isGL_NV_fragment_program = isExtensionSupported("GL_NV_fragment_program");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_NV_fragment_program ) // || isSEDEnable()
	{
		glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) getExtensionPtr( "glGetProgramNamedParameterdvNV" );
		if ( glGetProgramNamedParameterdvNV != 0 )	++localInitializedProcCount;

		glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) getExtensionPtr( "glGetProgramNamedParameterfvNV" );
		if ( glGetProgramNamedParameterfvNV != 0 )	++localInitializedProcCount;

		glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) getExtensionPtr( "glProgramNamedParameter4dNV" );
		if ( glProgramNamedParameter4dNV != 0 )	++localInitializedProcCount;

		glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) getExtensionPtr( "glProgramNamedParameter4dvNV" );
		if ( glProgramNamedParameter4dvNV != 0 )	++localInitializedProcCount;

		glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) getExtensionPtr( "glProgramNamedParameter4fNV" );
		if ( glProgramNamedParameter4fNV != 0 )	++localInitializedProcCount;

		glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) getExtensionPtr( "glProgramNamedParameter4fvNV" );
		if ( glProgramNamedParameter4fvNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_fragment_program )

	if ( isGL_NV_fragment_program )
	{
		std::stringstream strStream;
		strStream << "GL_NV_fragment_program                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_fragment_program                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_fragment_program") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_fragment_program                            : not detected." );
	}


	isGL_NV_fragment_program2 = isExtensionSupported("GL_NV_fragment_program2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_fragment_program2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_fragment_program2                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_fragment_program2                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_fragment_program2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_fragment_program2                           : not detected." );
	}


	isGL_NV_fragment_program4 = isExtensionSupported("GL_NV_fragment_program4");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_fragment_program4 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_fragment_program4                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_fragment_program4                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_fragment_program4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_fragment_program4                           : not detected." );
	}


	isGL_NV_fragment_program_option = isExtensionSupported("GL_NV_fragment_program_option");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_fragment_program_option )
	{
		std::stringstream strStream;
		strStream << "GL_NV_fragment_program_option                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_fragment_program_option                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_fragment_program_option") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_fragment_program_option                     : not detected." );
	}


	isGL_NV_framebuffer_multisample_coverage = isExtensionSupported("GL_NV_framebuffer_multisample_coverage");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_NV_framebuffer_multisample_coverage ) // || isSEDEnable()
	{
		glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) getExtensionPtr( "glRenderbufferStorageMultisampleCoverageNV" );
		if ( glRenderbufferStorageMultisampleCoverageNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_framebuffer_multisample_coverage )

	if ( isGL_NV_framebuffer_multisample_coverage )
	{
		std::stringstream strStream;
		strStream << "GL_NV_framebuffer_multisample_coverage            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_framebuffer_multisample_coverage            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_framebuffer_multisample_coverage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_framebuffer_multisample_coverage            : not detected." );
	}


	isGL_NV_geometry_program4 = isExtensionSupported("GL_NV_geometry_program4");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_NV_geometry_program4 ) // || isSEDEnable()
	{
		glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC) getExtensionPtr( "glFramebufferTextureEXT" );
		if ( glFramebufferTextureEXT != 0 )	++localInitializedProcCount;

		glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) getExtensionPtr( "glFramebufferTextureFaceEXT" );
		if ( glFramebufferTextureFaceEXT != 0 )	++localInitializedProcCount;

		glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) getExtensionPtr( "glFramebufferTextureLayerEXT" );
		if ( glFramebufferTextureLayerEXT != 0 )	++localInitializedProcCount;

		glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC) getExtensionPtr( "glProgramVertexLimitNV" );
		if ( glProgramVertexLimitNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_geometry_program4 )

	if ( isGL_NV_geometry_program4 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_geometry_program4                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_geometry_program4                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_geometry_program4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_geometry_program4                           : not detected." );
	}


	isGL_NV_geometry_shader4 = isExtensionSupported("GL_NV_geometry_shader4");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_geometry_shader4 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_geometry_shader4                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_geometry_shader4                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_geometry_shader4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_geometry_shader4                            : not detected." );
	}


	isGL_NV_gpu_program4 = isExtensionSupported("GL_NV_gpu_program4");

	localSupportedProcCount		= 16;
	localInitializedProcCount	= 0;

	if ( isGL_NV_gpu_program4 ) // || isSEDEnable()
	{
		glGetProgramEnvParameterIivNV = (PFNGLGETPROGRAMENVPARAMETERIIVNVPROC) getExtensionPtr( "glGetProgramEnvParameterIivNV" );
		if ( glGetProgramEnvParameterIivNV != 0 )	++localInitializedProcCount;

		glGetProgramEnvParameterIuivNV = (PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC) getExtensionPtr( "glGetProgramEnvParameterIuivNV" );
		if ( glGetProgramEnvParameterIuivNV != 0 )	++localInitializedProcCount;

		glGetProgramLocalParameterIivNV = (PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC) getExtensionPtr( "glGetProgramLocalParameterIivNV" );
		if ( glGetProgramLocalParameterIivNV != 0 )	++localInitializedProcCount;

		glGetProgramLocalParameterIuivNV = (PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC) getExtensionPtr( "glGetProgramLocalParameterIuivNV" );
		if ( glGetProgramLocalParameterIuivNV != 0 )	++localInitializedProcCount;

		glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC) getExtensionPtr( "glProgramEnvParameterI4iNV" );
		if ( glProgramEnvParameterI4iNV != 0 )	++localInitializedProcCount;

		glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC) getExtensionPtr( "glProgramEnvParameterI4ivNV" );
		if ( glProgramEnvParameterI4ivNV != 0 )	++localInitializedProcCount;

		glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC) getExtensionPtr( "glProgramEnvParameterI4uiNV" );
		if ( glProgramEnvParameterI4uiNV != 0 )	++localInitializedProcCount;

		glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) getExtensionPtr( "glProgramEnvParameterI4uivNV" );
		if ( glProgramEnvParameterI4uivNV != 0 )	++localInitializedProcCount;

		glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) getExtensionPtr( "glProgramEnvParametersI4ivNV" );
		if ( glProgramEnvParametersI4ivNV != 0 )	++localInitializedProcCount;

		glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) getExtensionPtr( "glProgramEnvParametersI4uivNV" );
		if ( glProgramEnvParametersI4uivNV != 0 )	++localInitializedProcCount;

		glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC) getExtensionPtr( "glProgramLocalParameterI4iNV" );
		if ( glProgramLocalParameterI4iNV != 0 )	++localInitializedProcCount;

		glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) getExtensionPtr( "glProgramLocalParameterI4ivNV" );
		if ( glProgramLocalParameterI4ivNV != 0 )	++localInitializedProcCount;

		glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) getExtensionPtr( "glProgramLocalParameterI4uiNV" );
		if ( glProgramLocalParameterI4uiNV != 0 )	++localInitializedProcCount;

		glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) getExtensionPtr( "glProgramLocalParameterI4uivNV" );
		if ( glProgramLocalParameterI4uivNV != 0 )	++localInitializedProcCount;

		glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) getExtensionPtr( "glProgramLocalParametersI4ivNV" );
		if ( glProgramLocalParametersI4ivNV != 0 )	++localInitializedProcCount;

		glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) getExtensionPtr( "glProgramLocalParametersI4uivNV" );
		if ( glProgramLocalParametersI4uivNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_gpu_program4 )

	if ( isGL_NV_gpu_program4 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_gpu_program4                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_gpu_program4                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_gpu_program4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_gpu_program4                                : not detected." );
	}


	isGL_NV_gpu_program5 = isExtensionSupported("GL_NV_gpu_program5");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_gpu_program5 ) // || isSEDEnable()
	{
		glGetProgramSubroutineParameteruivNV = (PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC) getExtensionPtr( "glGetProgramSubroutineParameteruivNV" );
		if ( glGetProgramSubroutineParameteruivNV != 0 )	++localInitializedProcCount;

		glProgramSubroutineParametersuivNV = (PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC) getExtensionPtr( "glProgramSubroutineParametersuivNV" );
		if ( glProgramSubroutineParametersuivNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_gpu_program5 )

	if ( isGL_NV_gpu_program5 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_gpu_program5                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_gpu_program5                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_gpu_program5") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_gpu_program5                                : not detected." );
	}


	isGL_NV_gpu_shader5 = isExtensionSupported("GL_NV_gpu_shader5");

	localSupportedProcCount		= 33;
	localInitializedProcCount	= 0;

	if ( isGL_NV_gpu_shader5 ) // || isSEDEnable()
	{
		glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC) getExtensionPtr( "glGetUniformi64vNV" );
		if ( glGetUniformi64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC) getExtensionPtr( "glProgramUniform1i64NV" );
		if ( glProgramUniform1i64NV != 0 )	++localInitializedProcCount;

		glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC) getExtensionPtr( "glProgramUniform1i64vNV" );
		if ( glProgramUniform1i64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC) getExtensionPtr( "glProgramUniform1ui64NV" );
		if ( glProgramUniform1ui64NV != 0 )	++localInitializedProcCount;

		glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC) getExtensionPtr( "glProgramUniform1ui64vNV" );
		if ( glProgramUniform1ui64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC) getExtensionPtr( "glProgramUniform2i64NV" );
		if ( glProgramUniform2i64NV != 0 )	++localInitializedProcCount;

		glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC) getExtensionPtr( "glProgramUniform2i64vNV" );
		if ( glProgramUniform2i64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC) getExtensionPtr( "glProgramUniform2ui64NV" );
		if ( glProgramUniform2ui64NV != 0 )	++localInitializedProcCount;

		glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC) getExtensionPtr( "glProgramUniform2ui64vNV" );
		if ( glProgramUniform2ui64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC) getExtensionPtr( "glProgramUniform3i64NV" );
		if ( glProgramUniform3i64NV != 0 )	++localInitializedProcCount;

		glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC) getExtensionPtr( "glProgramUniform3i64vNV" );
		if ( glProgramUniform3i64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC) getExtensionPtr( "glProgramUniform3ui64NV" );
		if ( glProgramUniform3ui64NV != 0 )	++localInitializedProcCount;

		glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC) getExtensionPtr( "glProgramUniform3ui64vNV" );
		if ( glProgramUniform3ui64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC) getExtensionPtr( "glProgramUniform4i64NV" );
		if ( glProgramUniform4i64NV != 0 )	++localInitializedProcCount;

		glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC) getExtensionPtr( "glProgramUniform4i64vNV" );
		if ( glProgramUniform4i64vNV != 0 )	++localInitializedProcCount;

		glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC) getExtensionPtr( "glProgramUniform4ui64NV" );
		if ( glProgramUniform4ui64NV != 0 )	++localInitializedProcCount;

		glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC) getExtensionPtr( "glProgramUniform4ui64vNV" );
		if ( glProgramUniform4ui64vNV != 0 )	++localInitializedProcCount;

		glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC) getExtensionPtr( "glUniform1i64NV" );
		if ( glUniform1i64NV != 0 )	++localInitializedProcCount;

		glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC) getExtensionPtr( "glUniform1i64vNV" );
		if ( glUniform1i64vNV != 0 )	++localInitializedProcCount;

		glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC) getExtensionPtr( "glUniform1ui64NV" );
		if ( glUniform1ui64NV != 0 )	++localInitializedProcCount;

		glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC) getExtensionPtr( "glUniform1ui64vNV" );
		if ( glUniform1ui64vNV != 0 )	++localInitializedProcCount;

		glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC) getExtensionPtr( "glUniform2i64NV" );
		if ( glUniform2i64NV != 0 )	++localInitializedProcCount;

		glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC) getExtensionPtr( "glUniform2i64vNV" );
		if ( glUniform2i64vNV != 0 )	++localInitializedProcCount;

		glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC) getExtensionPtr( "glUniform2ui64NV" );
		if ( glUniform2ui64NV != 0 )	++localInitializedProcCount;

		glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC) getExtensionPtr( "glUniform2ui64vNV" );
		if ( glUniform2ui64vNV != 0 )	++localInitializedProcCount;

		glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC) getExtensionPtr( "glUniform3i64NV" );
		if ( glUniform3i64NV != 0 )	++localInitializedProcCount;

		glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC) getExtensionPtr( "glUniform3i64vNV" );
		if ( glUniform3i64vNV != 0 )	++localInitializedProcCount;

		glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC) getExtensionPtr( "glUniform3ui64NV" );
		if ( glUniform3ui64NV != 0 )	++localInitializedProcCount;

		glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC) getExtensionPtr( "glUniform3ui64vNV" );
		if ( glUniform3ui64vNV != 0 )	++localInitializedProcCount;

		glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC) getExtensionPtr( "glUniform4i64NV" );
		if ( glUniform4i64NV != 0 )	++localInitializedProcCount;

		glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC) getExtensionPtr( "glUniform4i64vNV" );
		if ( glUniform4i64vNV != 0 )	++localInitializedProcCount;

		glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC) getExtensionPtr( "glUniform4ui64NV" );
		if ( glUniform4ui64NV != 0 )	++localInitializedProcCount;

		glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC) getExtensionPtr( "glUniform4ui64vNV" );
		if ( glUniform4ui64vNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_gpu_shader5 )

	if ( isGL_NV_gpu_shader5 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_gpu_shader5                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_gpu_shader5                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_gpu_shader5") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_gpu_shader5                                 : not detected." );
	}


	isGL_NV_half_float = isExtensionSupported("GL_NV_half_float");

	localSupportedProcCount		= 46;
	localInitializedProcCount	= 0;

	if ( isGL_NV_half_float ) // || isSEDEnable()
	{
		glColor3hNV = (PFNGLCOLOR3HNVPROC) getExtensionPtr( "glColor3hNV" );
		if ( glColor3hNV != 0 )	++localInitializedProcCount;

		glColor3hvNV = (PFNGLCOLOR3HVNVPROC) getExtensionPtr( "glColor3hvNV" );
		if ( glColor3hvNV != 0 )	++localInitializedProcCount;

		glColor4hNV = (PFNGLCOLOR4HNVPROC) getExtensionPtr( "glColor4hNV" );
		if ( glColor4hNV != 0 )	++localInitializedProcCount;

		glColor4hvNV = (PFNGLCOLOR4HVNVPROC) getExtensionPtr( "glColor4hvNV" );
		if ( glColor4hvNV != 0 )	++localInitializedProcCount;

		glFogCoordhNV = (PFNGLFOGCOORDHNVPROC) getExtensionPtr( "glFogCoordhNV" );
		if ( glFogCoordhNV != 0 )	++localInitializedProcCount;

		glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC) getExtensionPtr( "glFogCoordhvNV" );
		if ( glFogCoordhvNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC) getExtensionPtr( "glMultiTexCoord1hNV" );
		if ( glMultiTexCoord1hNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC) getExtensionPtr( "glMultiTexCoord1hvNV" );
		if ( glMultiTexCoord1hvNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC) getExtensionPtr( "glMultiTexCoord2hNV" );
		if ( glMultiTexCoord2hNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC) getExtensionPtr( "glMultiTexCoord2hvNV" );
		if ( glMultiTexCoord2hvNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC) getExtensionPtr( "glMultiTexCoord3hNV" );
		if ( glMultiTexCoord3hNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC) getExtensionPtr( "glMultiTexCoord3hvNV" );
		if ( glMultiTexCoord3hvNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC) getExtensionPtr( "glMultiTexCoord4hNV" );
		if ( glMultiTexCoord4hNV != 0 )	++localInitializedProcCount;

		glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC) getExtensionPtr( "glMultiTexCoord4hvNV" );
		if ( glMultiTexCoord4hvNV != 0 )	++localInitializedProcCount;

		glNormal3hNV = (PFNGLNORMAL3HNVPROC) getExtensionPtr( "glNormal3hNV" );
		if ( glNormal3hNV != 0 )	++localInitializedProcCount;

		glNormal3hvNV = (PFNGLNORMAL3HVNVPROC) getExtensionPtr( "glNormal3hvNV" );
		if ( glNormal3hvNV != 0 )	++localInitializedProcCount;

		glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC) getExtensionPtr( "glSecondaryColor3hNV" );
		if ( glSecondaryColor3hNV != 0 )	++localInitializedProcCount;

		glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC) getExtensionPtr( "glSecondaryColor3hvNV" );
		if ( glSecondaryColor3hvNV != 0 )	++localInitializedProcCount;

		glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC) getExtensionPtr( "glTexCoord1hNV" );
		if ( glTexCoord1hNV != 0 )	++localInitializedProcCount;

		glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC) getExtensionPtr( "glTexCoord1hvNV" );
		if ( glTexCoord1hvNV != 0 )	++localInitializedProcCount;

		glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC) getExtensionPtr( "glTexCoord2hNV" );
		if ( glTexCoord2hNV != 0 )	++localInitializedProcCount;

		glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC) getExtensionPtr( "glTexCoord2hvNV" );
		if ( glTexCoord2hvNV != 0 )	++localInitializedProcCount;

		glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC) getExtensionPtr( "glTexCoord3hNV" );
		if ( glTexCoord3hNV != 0 )	++localInitializedProcCount;

		glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC) getExtensionPtr( "glTexCoord3hvNV" );
		if ( glTexCoord3hvNV != 0 )	++localInitializedProcCount;

		glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC) getExtensionPtr( "glTexCoord4hNV" );
		if ( glTexCoord4hNV != 0 )	++localInitializedProcCount;

		glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC) getExtensionPtr( "glTexCoord4hvNV" );
		if ( glTexCoord4hvNV != 0 )	++localInitializedProcCount;

		glVertex2hNV = (PFNGLVERTEX2HNVPROC) getExtensionPtr( "glVertex2hNV" );
		if ( glVertex2hNV != 0 )	++localInitializedProcCount;

		glVertex2hvNV = (PFNGLVERTEX2HVNVPROC) getExtensionPtr( "glVertex2hvNV" );
		if ( glVertex2hvNV != 0 )	++localInitializedProcCount;

		glVertex3hNV = (PFNGLVERTEX3HNVPROC) getExtensionPtr( "glVertex3hNV" );
		if ( glVertex3hNV != 0 )	++localInitializedProcCount;

		glVertex3hvNV = (PFNGLVERTEX3HVNVPROC) getExtensionPtr( "glVertex3hvNV" );
		if ( glVertex3hvNV != 0 )	++localInitializedProcCount;

		glVertex4hNV = (PFNGLVERTEX4HNVPROC) getExtensionPtr( "glVertex4hNV" );
		if ( glVertex4hNV != 0 )	++localInitializedProcCount;

		glVertex4hvNV = (PFNGLVERTEX4HVNVPROC) getExtensionPtr( "glVertex4hvNV" );
		if ( glVertex4hvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC) getExtensionPtr( "glVertexAttrib1hNV" );
		if ( glVertexAttrib1hNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC) getExtensionPtr( "glVertexAttrib1hvNV" );
		if ( glVertexAttrib1hvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC) getExtensionPtr( "glVertexAttrib2hNV" );
		if ( glVertexAttrib2hNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC) getExtensionPtr( "glVertexAttrib2hvNV" );
		if ( glVertexAttrib2hvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC) getExtensionPtr( "glVertexAttrib3hNV" );
		if ( glVertexAttrib3hNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC) getExtensionPtr( "glVertexAttrib3hvNV" );
		if ( glVertexAttrib3hvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC) getExtensionPtr( "glVertexAttrib4hNV" );
		if ( glVertexAttrib4hNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC) getExtensionPtr( "glVertexAttrib4hvNV" );
		if ( glVertexAttrib4hvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC) getExtensionPtr( "glVertexAttribs1hvNV" );
		if ( glVertexAttribs1hvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC) getExtensionPtr( "glVertexAttribs2hvNV" );
		if ( glVertexAttribs2hvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC) getExtensionPtr( "glVertexAttribs3hvNV" );
		if ( glVertexAttribs3hvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC) getExtensionPtr( "glVertexAttribs4hvNV" );
		if ( glVertexAttribs4hvNV != 0 )	++localInitializedProcCount;

		glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC) getExtensionPtr( "glVertexWeighthNV" );
		if ( glVertexWeighthNV != 0 )	++localInitializedProcCount;

		glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC) getExtensionPtr( "glVertexWeighthvNV" );
		if ( glVertexWeighthvNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_half_float )

	if ( isGL_NV_half_float )
	{
		std::stringstream strStream;
		strStream << "GL_NV_half_float                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_half_float                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_half_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_half_float                                  : not detected." );
	}


	isGL_NV_light_max_exponent = isExtensionSupported("GL_NV_light_max_exponent");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_light_max_exponent )
	{
		std::stringstream strStream;
		strStream << "GL_NV_light_max_exponent                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_light_max_exponent                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_light_max_exponent") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_light_max_exponent                          : not detected." );
	}


	isGL_NV_multisample_coverage = isExtensionSupported("GL_NV_multisample_coverage");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_multisample_coverage )
	{
		std::stringstream strStream;
		strStream << "GL_NV_multisample_coverage                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_multisample_coverage                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_multisample_coverage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_multisample_coverage                        : not detected." );
	}


	isGL_NV_multisample_filter_hint = isExtensionSupported("GL_NV_multisample_filter_hint");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_multisample_filter_hint )
	{
		std::stringstream strStream;
		strStream << "GL_NV_multisample_filter_hint                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_multisample_filter_hint                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_multisample_filter_hint") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_multisample_filter_hint                     : not detected." );
	}


	isGL_NV_occlusion_query = isExtensionSupported("GL_NV_occlusion_query");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_NV_occlusion_query ) // || isSEDEnable()
	{
		glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC) getExtensionPtr( "glBeginOcclusionQueryNV" );
		if ( glBeginOcclusionQueryNV != 0 )	++localInitializedProcCount;

		glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC) getExtensionPtr( "glDeleteOcclusionQueriesNV" );
		if ( glDeleteOcclusionQueriesNV != 0 )	++localInitializedProcCount;

		glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC) getExtensionPtr( "glEndOcclusionQueryNV" );
		if ( glEndOcclusionQueryNV != 0 )	++localInitializedProcCount;

		glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC) getExtensionPtr( "glGenOcclusionQueriesNV" );
		if ( glGenOcclusionQueriesNV != 0 )	++localInitializedProcCount;

		glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC) getExtensionPtr( "glGetOcclusionQueryivNV" );
		if ( glGetOcclusionQueryivNV != 0 )	++localInitializedProcCount;

		glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC) getExtensionPtr( "glGetOcclusionQueryuivNV" );
		if ( glGetOcclusionQueryuivNV != 0 )	++localInitializedProcCount;

		glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC) getExtensionPtr( "glIsOcclusionQueryNV" );
		if ( glIsOcclusionQueryNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_occlusion_query )

	if ( isGL_NV_occlusion_query )
	{
		std::stringstream strStream;
		strStream << "GL_NV_occlusion_query                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_occlusion_query                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_occlusion_query") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_occlusion_query                             : not detected." );
	}


	isGL_NV_packed_depth_stencil = isExtensionSupported("GL_NV_packed_depth_stencil");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_packed_depth_stencil )
	{
		std::stringstream strStream;
		strStream << "GL_NV_packed_depth_stencil                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_packed_depth_stencil                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_packed_depth_stencil") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_packed_depth_stencil                        : not detected." );
	}


	isGL_NV_parameter_buffer_object = isExtensionSupported("GL_NV_parameter_buffer_object");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_NV_parameter_buffer_object ) // || isSEDEnable()
	{
		glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) getExtensionPtr( "glProgramBufferParametersIivNV" );
		if ( glProgramBufferParametersIivNV != 0 )	++localInitializedProcCount;

		glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) getExtensionPtr( "glProgramBufferParametersIuivNV" );
		if ( glProgramBufferParametersIuivNV != 0 )	++localInitializedProcCount;

		glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) getExtensionPtr( "glProgramBufferParametersfvNV" );
		if ( glProgramBufferParametersfvNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_parameter_buffer_object )

	if ( isGL_NV_parameter_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_NV_parameter_buffer_object                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_parameter_buffer_object                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_parameter_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_parameter_buffer_object                     : not detected." );
	}


	isGL_NV_parameter_buffer_object2 = isExtensionSupported("GL_NV_parameter_buffer_object2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_parameter_buffer_object2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_parameter_buffer_object2                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_parameter_buffer_object2                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_parameter_buffer_object2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_parameter_buffer_object2                    : not detected." );
	}


	isGL_NV_path_rendering = isExtensionSupported("GL_NV_path_rendering");

	localSupportedProcCount		= 49;
	localInitializedProcCount	= 0;

	if ( isGL_NV_path_rendering ) // || isSEDEnable()
	{
		glCopyPathNV = (PFNGLCOPYPATHNVPROC) getExtensionPtr( "glCopyPathNV" );
		if ( glCopyPathNV != 0 )	++localInitializedProcCount;

		glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC) getExtensionPtr( "glCoverFillPathInstancedNV" );
		if ( glCoverFillPathInstancedNV != 0 )	++localInitializedProcCount;

		glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC) getExtensionPtr( "glCoverFillPathNV" );
		if ( glCoverFillPathNV != 0 )	++localInitializedProcCount;

		glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC) getExtensionPtr( "glCoverStrokePathInstancedNV" );
		if ( glCoverStrokePathInstancedNV != 0 )	++localInitializedProcCount;

		glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC) getExtensionPtr( "glCoverStrokePathNV" );
		if ( glCoverStrokePathNV != 0 )	++localInitializedProcCount;

		glDeletePathsNV = (PFNGLDELETEPATHSNVPROC) getExtensionPtr( "glDeletePathsNV" );
		if ( glDeletePathsNV != 0 )	++localInitializedProcCount;

		glGenPathsNV = (PFNGLGENPATHSNVPROC) getExtensionPtr( "glGenPathsNV" );
		if ( glGenPathsNV != 0 )	++localInitializedProcCount;

		glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC) getExtensionPtr( "glGetPathColorGenfvNV" );
		if ( glGetPathColorGenfvNV != 0 )	++localInitializedProcCount;

		glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC) getExtensionPtr( "glGetPathColorGenivNV" );
		if ( glGetPathColorGenivNV != 0 )	++localInitializedProcCount;

		glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC) getExtensionPtr( "glGetPathCommandsNV" );
		if ( glGetPathCommandsNV != 0 )	++localInitializedProcCount;

		glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC) getExtensionPtr( "glGetPathCoordsNV" );
		if ( glGetPathCoordsNV != 0 )	++localInitializedProcCount;

		glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC) getExtensionPtr( "glGetPathDashArrayNV" );
		if ( glGetPathDashArrayNV != 0 )	++localInitializedProcCount;

		glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC) getExtensionPtr( "glGetPathLengthNV" );
		if ( glGetPathLengthNV != 0 )	++localInitializedProcCount;

		glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC) getExtensionPtr( "glGetPathMetricRangeNV" );
		if ( glGetPathMetricRangeNV != 0 )	++localInitializedProcCount;

		glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC) getExtensionPtr( "glGetPathMetricsNV" );
		if ( glGetPathMetricsNV != 0 )	++localInitializedProcCount;

		glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC) getExtensionPtr( "glGetPathParameterfvNV" );
		if ( glGetPathParameterfvNV != 0 )	++localInitializedProcCount;

		glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC) getExtensionPtr( "glGetPathParameterivNV" );
		if ( glGetPathParameterivNV != 0 )	++localInitializedProcCount;

		glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC) getExtensionPtr( "glGetPathSpacingNV" );
		if ( glGetPathSpacingNV != 0 )	++localInitializedProcCount;

		glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC) getExtensionPtr( "glGetPathTexGenfvNV" );
		if ( glGetPathTexGenfvNV != 0 )	++localInitializedProcCount;

		glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC) getExtensionPtr( "glGetPathTexGenivNV" );
		if ( glGetPathTexGenivNV != 0 )	++localInitializedProcCount;

		glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC) getExtensionPtr( "glInterpolatePathsNV" );
		if ( glInterpolatePathsNV != 0 )	++localInitializedProcCount;

		glIsPathNV = (PFNGLISPATHNVPROC) getExtensionPtr( "glIsPathNV" );
		if ( glIsPathNV != 0 )	++localInitializedProcCount;

		glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC) getExtensionPtr( "glIsPointInFillPathNV" );
		if ( glIsPointInFillPathNV != 0 )	++localInitializedProcCount;

		glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC) getExtensionPtr( "glIsPointInStrokePathNV" );
		if ( glIsPointInStrokePathNV != 0 )	++localInitializedProcCount;

		glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC) getExtensionPtr( "glPathColorGenNV" );
		if ( glPathColorGenNV != 0 )	++localInitializedProcCount;

		glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC) getExtensionPtr( "glPathCommandsNV" );
		if ( glPathCommandsNV != 0 )	++localInitializedProcCount;

		glPathCoordsNV = (PFNGLPATHCOORDSNVPROC) getExtensionPtr( "glPathCoordsNV" );
		if ( glPathCoordsNV != 0 )	++localInitializedProcCount;

		glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC) getExtensionPtr( "glPathCoverDepthFuncNV" );
		if ( glPathCoverDepthFuncNV != 0 )	++localInitializedProcCount;

		glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC) getExtensionPtr( "glPathDashArrayNV" );
		if ( glPathDashArrayNV != 0 )	++localInitializedProcCount;

		glPathFogGenNV = (PFNGLPATHFOGGENNVPROC) getExtensionPtr( "glPathFogGenNV" );
		if ( glPathFogGenNV != 0 )	++localInitializedProcCount;

		glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC) getExtensionPtr( "glPathGlyphRangeNV" );
		if ( glPathGlyphRangeNV != 0 )	++localInitializedProcCount;

		glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC) getExtensionPtr( "glPathGlyphsNV" );
		if ( glPathGlyphsNV != 0 )	++localInitializedProcCount;

		glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC) getExtensionPtr( "glPathParameterfNV" );
		if ( glPathParameterfNV != 0 )	++localInitializedProcCount;

		glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC) getExtensionPtr( "glPathParameterfvNV" );
		if ( glPathParameterfvNV != 0 )	++localInitializedProcCount;

		glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC) getExtensionPtr( "glPathParameteriNV" );
		if ( glPathParameteriNV != 0 )	++localInitializedProcCount;

		glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC) getExtensionPtr( "glPathParameterivNV" );
		if ( glPathParameterivNV != 0 )	++localInitializedProcCount;

		glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC) getExtensionPtr( "glPathStencilDepthOffsetNV" );
		if ( glPathStencilDepthOffsetNV != 0 )	++localInitializedProcCount;

		glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC) getExtensionPtr( "glPathStencilFuncNV" );
		if ( glPathStencilFuncNV != 0 )	++localInitializedProcCount;

		glPathStringNV = (PFNGLPATHSTRINGNVPROC) getExtensionPtr( "glPathStringNV" );
		if ( glPathStringNV != 0 )	++localInitializedProcCount;

		glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC) getExtensionPtr( "glPathSubCommandsNV" );
		if ( glPathSubCommandsNV != 0 )	++localInitializedProcCount;

		glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC) getExtensionPtr( "glPathSubCoordsNV" );
		if ( glPathSubCoordsNV != 0 )	++localInitializedProcCount;

		glPathTexGenNV = (PFNGLPATHTEXGENNVPROC) getExtensionPtr( "glPathTexGenNV" );
		if ( glPathTexGenNV != 0 )	++localInitializedProcCount;

		glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC) getExtensionPtr( "glPointAlongPathNV" );
		if ( glPointAlongPathNV != 0 )	++localInitializedProcCount;

		glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC) getExtensionPtr( "glStencilFillPathInstancedNV" );
		if ( glStencilFillPathInstancedNV != 0 )	++localInitializedProcCount;

		glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC) getExtensionPtr( "glStencilFillPathNV" );
		if ( glStencilFillPathNV != 0 )	++localInitializedProcCount;

		glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC) getExtensionPtr( "glStencilStrokePathInstancedNV" );
		if ( glStencilStrokePathInstancedNV != 0 )	++localInitializedProcCount;

		glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC) getExtensionPtr( "glStencilStrokePathNV" );
		if ( glStencilStrokePathNV != 0 )	++localInitializedProcCount;

		glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC) getExtensionPtr( "glTransformPathNV" );
		if ( glTransformPathNV != 0 )	++localInitializedProcCount;

		glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC) getExtensionPtr( "glWeightPathsNV" );
		if ( glWeightPathsNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_path_rendering )

	if ( isGL_NV_path_rendering )
	{
		std::stringstream strStream;
		strStream << "GL_NV_path_rendering                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_path_rendering                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_path_rendering") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_path_rendering                              : not detected." );
	}


	isGL_NV_pixel_data_range = isExtensionSupported("GL_NV_pixel_data_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_pixel_data_range ) // || isSEDEnable()
	{
		glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC) getExtensionPtr( "glFlushPixelDataRangeNV" );
		if ( glFlushPixelDataRangeNV != 0 )	++localInitializedProcCount;

		glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC) getExtensionPtr( "glPixelDataRangeNV" );
		if ( glPixelDataRangeNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_pixel_data_range )

	if ( isGL_NV_pixel_data_range )
	{
		std::stringstream strStream;
		strStream << "GL_NV_pixel_data_range                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_pixel_data_range                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_pixel_data_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_pixel_data_range                            : not detected." );
	}


	isGL_NV_point_sprite = isExtensionSupported("GL_NV_point_sprite");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_point_sprite ) // || isSEDEnable()
	{
		glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC) getExtensionPtr( "glPointParameteriNV" );
		if ( glPointParameteriNV != 0 )	++localInitializedProcCount;

		glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC) getExtensionPtr( "glPointParameterivNV" );
		if ( glPointParameterivNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_point_sprite )

	if ( isGL_NV_point_sprite )
	{
		std::stringstream strStream;
		strStream << "GL_NV_point_sprite                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_point_sprite                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_point_sprite") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_point_sprite                                : not detected." );
	}


	isGL_NV_present_video = isExtensionSupported("GL_NV_present_video");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_NV_present_video ) // || isSEDEnable()
	{
		glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC) getExtensionPtr( "glGetVideoi64vNV" );
		if ( glGetVideoi64vNV != 0 )	++localInitializedProcCount;

		glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC) getExtensionPtr( "glGetVideoivNV" );
		if ( glGetVideoivNV != 0 )	++localInitializedProcCount;

		glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC) getExtensionPtr( "glGetVideoui64vNV" );
		if ( glGetVideoui64vNV != 0 )	++localInitializedProcCount;

		glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC) getExtensionPtr( "glGetVideouivNV" );
		if ( glGetVideouivNV != 0 )	++localInitializedProcCount;

		glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC) getExtensionPtr( "glPresentFrameDualFillNV" );
		if ( glPresentFrameDualFillNV != 0 )	++localInitializedProcCount;

		glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC) getExtensionPtr( "glPresentFrameKeyedNV" );
		if ( glPresentFrameKeyedNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_present_video )

	if ( isGL_NV_present_video )
	{
		std::stringstream strStream;
		strStream << "GL_NV_present_video                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_present_video                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_present_video") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_present_video                               : not detected." );
	}


	isGL_NV_primitive_restart = isExtensionSupported("GL_NV_primitive_restart");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_primitive_restart ) // || isSEDEnable()
	{
		glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC) getExtensionPtr( "glPrimitiveRestartIndexNV" );
		if ( glPrimitiveRestartIndexNV != 0 )	++localInitializedProcCount;

		glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC) getExtensionPtr( "glPrimitiveRestartNV" );
		if ( glPrimitiveRestartNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_primitive_restart )

	if ( isGL_NV_primitive_restart )
	{
		std::stringstream strStream;
		strStream << "GL_NV_primitive_restart                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_primitive_restart                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_primitive_restart") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_primitive_restart                           : not detected." );
	}


	isGL_NV_register_combiners = isExtensionSupported("GL_NV_register_combiners");

	localSupportedProcCount		= 13;
	localInitializedProcCount	= 0;

	if ( isGL_NV_register_combiners ) // || isSEDEnable()
	{
		glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC) getExtensionPtr( "glCombinerInputNV" );
		if ( glCombinerInputNV != 0 )	++localInitializedProcCount;

		glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC) getExtensionPtr( "glCombinerOutputNV" );
		if ( glCombinerOutputNV != 0 )	++localInitializedProcCount;

		glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC) getExtensionPtr( "glCombinerParameterfNV" );
		if ( glCombinerParameterfNV != 0 )	++localInitializedProcCount;

		glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC) getExtensionPtr( "glCombinerParameterfvNV" );
		if ( glCombinerParameterfvNV != 0 )	++localInitializedProcCount;

		glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC) getExtensionPtr( "glCombinerParameteriNV" );
		if ( glCombinerParameteriNV != 0 )	++localInitializedProcCount;

		glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC) getExtensionPtr( "glCombinerParameterivNV" );
		if ( glCombinerParameterivNV != 0 )	++localInitializedProcCount;

		glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC) getExtensionPtr( "glFinalCombinerInputNV" );
		if ( glFinalCombinerInputNV != 0 )	++localInitializedProcCount;

		glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) getExtensionPtr( "glGetCombinerInputParameterfvNV" );
		if ( glGetCombinerInputParameterfvNV != 0 )	++localInitializedProcCount;

		glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) getExtensionPtr( "glGetCombinerInputParameterivNV" );
		if ( glGetCombinerInputParameterivNV != 0 )	++localInitializedProcCount;

		glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) getExtensionPtr( "glGetCombinerOutputParameterfvNV" );
		if ( glGetCombinerOutputParameterfvNV != 0 )	++localInitializedProcCount;

		glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) getExtensionPtr( "glGetCombinerOutputParameterivNV" );
		if ( glGetCombinerOutputParameterivNV != 0 )	++localInitializedProcCount;

		glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) getExtensionPtr( "glGetFinalCombinerInputParameterfvNV" );
		if ( glGetFinalCombinerInputParameterfvNV != 0 )	++localInitializedProcCount;

		glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) getExtensionPtr( "glGetFinalCombinerInputParameterivNV" );
		if ( glGetFinalCombinerInputParameterivNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_register_combiners )

	if ( isGL_NV_register_combiners )
	{
		std::stringstream strStream;
		strStream << "GL_NV_register_combiners                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_register_combiners                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_register_combiners") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_register_combiners                          : not detected." );
	}


	isGL_NV_register_combiners2 = isExtensionSupported("GL_NV_register_combiners2");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_register_combiners2 ) // || isSEDEnable()
	{
		glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) getExtensionPtr( "glCombinerStageParameterfvNV" );
		if ( glCombinerStageParameterfvNV != 0 )	++localInitializedProcCount;

		glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) getExtensionPtr( "glGetCombinerStageParameterfvNV" );
		if ( glGetCombinerStageParameterfvNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_register_combiners2 )

	if ( isGL_NV_register_combiners2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_register_combiners2                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_register_combiners2                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_register_combiners2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_register_combiners2                         : not detected." );
	}


	isGL_NV_shader_atomic_counters = isExtensionSupported("GL_NV_shader_atomic_counters");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_shader_atomic_counters )
	{
		std::stringstream strStream;
		strStream << "GL_NV_shader_atomic_counters                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_shader_atomic_counters                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_shader_atomic_counters") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_shader_atomic_counters                      : not detected." );
	}


	isGL_NV_shader_atomic_float = isExtensionSupported("GL_NV_shader_atomic_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_shader_atomic_float )
	{
		std::stringstream strStream;
		strStream << "GL_NV_shader_atomic_float                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_shader_atomic_float                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_shader_atomic_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_shader_atomic_float                         : not detected." );
	}


	isGL_NV_shader_buffer_load = isExtensionSupported("GL_NV_shader_buffer_load");

	localSupportedProcCount		= 14;
	localInitializedProcCount	= 0;

	if ( isGL_NV_shader_buffer_load ) // || isSEDEnable()
	{
		glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC) getExtensionPtr( "glGetBufferParameterui64vNV" );
		if ( glGetBufferParameterui64vNV != 0 )	++localInitializedProcCount;

		glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC) getExtensionPtr( "glGetIntegerui64vNV" );
		if ( glGetIntegerui64vNV != 0 )	++localInitializedProcCount;

		glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC) getExtensionPtr( "glGetNamedBufferParameterui64vNV" );
		if ( glGetNamedBufferParameterui64vNV != 0 )	++localInitializedProcCount;

		glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC) getExtensionPtr( "glGetUniformui64vNV" );
		if ( glGetUniformui64vNV != 0 )	++localInitializedProcCount;

		glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC) getExtensionPtr( "glIsBufferResidentNV" );
		if ( glIsBufferResidentNV != 0 )	++localInitializedProcCount;

		glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC) getExtensionPtr( "glIsNamedBufferResidentNV" );
		if ( glIsNamedBufferResidentNV != 0 )	++localInitializedProcCount;

		glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC) getExtensionPtr( "glMakeBufferNonResidentNV" );
		if ( glMakeBufferNonResidentNV != 0 )	++localInitializedProcCount;

		glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC) getExtensionPtr( "glMakeBufferResidentNV" );
		if ( glMakeBufferResidentNV != 0 )	++localInitializedProcCount;

		glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC) getExtensionPtr( "glMakeNamedBufferNonResidentNV" );
		if ( glMakeNamedBufferNonResidentNV != 0 )	++localInitializedProcCount;

		glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC) getExtensionPtr( "glMakeNamedBufferResidentNV" );
		if ( glMakeNamedBufferResidentNV != 0 )	++localInitializedProcCount;

		glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC) getExtensionPtr( "glProgramUniformui64NV" );
		if ( glProgramUniformui64NV != 0 )	++localInitializedProcCount;

		glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC) getExtensionPtr( "glProgramUniformui64vNV" );
		if ( glProgramUniformui64vNV != 0 )	++localInitializedProcCount;

		glUniformui64NV = (PFNGLUNIFORMUI64NVPROC) getExtensionPtr( "glUniformui64NV" );
		if ( glUniformui64NV != 0 )	++localInitializedProcCount;

		glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC) getExtensionPtr( "glUniformui64vNV" );
		if ( glUniformui64vNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_shader_buffer_load )

	if ( isGL_NV_shader_buffer_load )
	{
		std::stringstream strStream;
		strStream << "GL_NV_shader_buffer_load                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_shader_buffer_load                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_shader_buffer_load") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_shader_buffer_load                          : not detected." );
	}


	isGL_NV_shader_buffer_store = isExtensionSupported("GL_NV_shader_buffer_store");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_shader_buffer_store )
	{
		std::stringstream strStream;
		strStream << "GL_NV_shader_buffer_store                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_shader_buffer_store                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_shader_buffer_store") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_shader_buffer_store                         : not detected." );
	}


	isGL_NV_shader_storage_buffer_object = isExtensionSupported("GL_NV_shader_storage_buffer_object");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_shader_storage_buffer_object )
	{
		std::stringstream strStream;
		strStream << "GL_NV_shader_storage_buffer_object                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_shader_storage_buffer_object                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_shader_storage_buffer_object") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_shader_storage_buffer_object                : not detected." );
	}


	isGL_NV_tessellation_program5 = isExtensionSupported("GL_NV_tessellation_program5");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_tessellation_program5 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_tessellation_program5                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_tessellation_program5                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_tessellation_program5") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_tessellation_program5                       : not detected." );
	}


	isGL_NV_texgen_emboss = isExtensionSupported("GL_NV_texgen_emboss");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texgen_emboss )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texgen_emboss                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texgen_emboss                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texgen_emboss") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texgen_emboss                               : not detected." );
	}


	isGL_NV_texgen_reflection = isExtensionSupported("GL_NV_texgen_reflection");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texgen_reflection )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texgen_reflection                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texgen_reflection                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texgen_reflection") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texgen_reflection                           : not detected." );
	}


	isGL_NV_texture_barrier = isExtensionSupported("GL_NV_texture_barrier");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_barrier ) // || isSEDEnable()
	{
		glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC) getExtensionPtr( "glTextureBarrierNV" );
		if ( glTextureBarrierNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_texture_barrier )

	if ( isGL_NV_texture_barrier )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_barrier                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_barrier                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_barrier") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_barrier                             : not detected." );
	}


	isGL_NV_texture_compression_vtc = isExtensionSupported("GL_NV_texture_compression_vtc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_compression_vtc )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_compression_vtc                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_compression_vtc                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_compression_vtc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_compression_vtc                     : not detected." );
	}


	isGL_NV_texture_env_combine4 = isExtensionSupported("GL_NV_texture_env_combine4");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_env_combine4 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_env_combine4                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_env_combine4                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_env_combine4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_env_combine4                        : not detected." );
	}


	isGL_NV_texture_expand_normal = isExtensionSupported("GL_NV_texture_expand_normal");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_expand_normal )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_expand_normal                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_expand_normal                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_expand_normal") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_expand_normal                       : not detected." );
	}


	isGL_NV_texture_multisample = isExtensionSupported("GL_NV_texture_multisample");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_multisample ) // || isSEDEnable()
	{
		glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC) getExtensionPtr( "glTexImage2DMultisampleCoverageNV" );
		if ( glTexImage2DMultisampleCoverageNV != 0 )	++localInitializedProcCount;

		glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC) getExtensionPtr( "glTexImage3DMultisampleCoverageNV" );
		if ( glTexImage3DMultisampleCoverageNV != 0 )	++localInitializedProcCount;

		glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC) getExtensionPtr( "glTextureImage2DMultisampleCoverageNV" );
		if ( glTextureImage2DMultisampleCoverageNV != 0 )	++localInitializedProcCount;

		glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC) getExtensionPtr( "glTextureImage2DMultisampleNV" );
		if ( glTextureImage2DMultisampleNV != 0 )	++localInitializedProcCount;

		glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC) getExtensionPtr( "glTextureImage3DMultisampleCoverageNV" );
		if ( glTextureImage3DMultisampleCoverageNV != 0 )	++localInitializedProcCount;

		glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) getExtensionPtr( "glTextureImage3DMultisampleNV" );
		if ( glTextureImage3DMultisampleNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_texture_multisample )

	if ( isGL_NV_texture_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_multisample                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_multisample                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_multisample                         : not detected." );
	}


	isGL_NV_texture_rectangle = isExtensionSupported("GL_NV_texture_rectangle");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_rectangle )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_rectangle                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_rectangle                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_rectangle") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_rectangle                           : not detected." );
	}


	isGL_NV_texture_shader = isExtensionSupported("GL_NV_texture_shader");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_shader )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_shader                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_shader                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_shader") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_shader                              : not detected." );
	}


	isGL_NV_texture_shader2 = isExtensionSupported("GL_NV_texture_shader2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_shader2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_shader2                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_shader2                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_shader2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_shader2                             : not detected." );
	}


	isGL_NV_texture_shader3 = isExtensionSupported("GL_NV_texture_shader3");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_texture_shader3 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_texture_shader3                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_texture_shader3                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_texture_shader3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_texture_shader3                             : not detected." );
	}


	isGL_NV_transform_feedback = isExtensionSupported("GL_NV_transform_feedback");

	localSupportedProcCount		= 12;
	localInitializedProcCount	= 0;

	if ( isGL_NV_transform_feedback ) // || isSEDEnable()
	{
		glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC) getExtensionPtr( "glActiveVaryingNV" );
		if ( glActiveVaryingNV != 0 )	++localInitializedProcCount;

		glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glBeginTransformFeedbackNV" );
		if ( glBeginTransformFeedbackNV != 0 )	++localInitializedProcCount;

		glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC) getExtensionPtr( "glBindBufferBaseNV" );
		if ( glBindBufferBaseNV != 0 )	++localInitializedProcCount;

		glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC) getExtensionPtr( "glBindBufferOffsetNV" );
		if ( glBindBufferOffsetNV != 0 )	++localInitializedProcCount;

		glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC) getExtensionPtr( "glBindBufferRangeNV" );
		if ( glBindBufferRangeNV != 0 )	++localInitializedProcCount;

		glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glEndTransformFeedbackNV" );
		if ( glEndTransformFeedbackNV != 0 )	++localInitializedProcCount;

		glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC) getExtensionPtr( "glGetActiveVaryingNV" );
		if ( glGetActiveVaryingNV != 0 )	++localInitializedProcCount;

		glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) getExtensionPtr( "glGetTransformFeedbackVaryingNV" );
		if ( glGetTransformFeedbackVaryingNV != 0 )	++localInitializedProcCount;

		glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC) getExtensionPtr( "glGetVaryingLocationNV" );
		if ( glGetVaryingLocationNV != 0 )	++localInitializedProcCount;

		glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) getExtensionPtr( "glTransformFeedbackAttribsNV" );
		if ( glTransformFeedbackAttribsNV != 0 )	++localInitializedProcCount;

		glTransformFeedbackStreamAttribsNV = (PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC) getExtensionPtr( "glTransformFeedbackStreamAttribsNV" );
		if ( glTransformFeedbackStreamAttribsNV != 0 )	++localInitializedProcCount;

		glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) getExtensionPtr( "glTransformFeedbackVaryingsNV" );
		if ( glTransformFeedbackVaryingsNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_transform_feedback )

	if ( isGL_NV_transform_feedback )
	{
		std::stringstream strStream;
		strStream << "GL_NV_transform_feedback                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_transform_feedback                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_transform_feedback") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_transform_feedback                          : not detected." );
	}


	isGL_NV_transform_feedback2 = isExtensionSupported("GL_NV_transform_feedback2");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_NV_transform_feedback2 ) // || isSEDEnable()
	{
		glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glBindTransformFeedbackNV" );
		if ( glBindTransformFeedbackNV != 0 )	++localInitializedProcCount;

		glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC) getExtensionPtr( "glDeleteTransformFeedbacksNV" );
		if ( glDeleteTransformFeedbacksNV != 0 )	++localInitializedProcCount;

		glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glDrawTransformFeedbackNV" );
		if ( glDrawTransformFeedbackNV != 0 )	++localInitializedProcCount;

		glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC) getExtensionPtr( "glGenTransformFeedbacksNV" );
		if ( glGenTransformFeedbacksNV != 0 )	++localInitializedProcCount;

		glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glIsTransformFeedbackNV" );
		if ( glIsTransformFeedbackNV != 0 )	++localInitializedProcCount;

		glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glPauseTransformFeedbackNV" );
		if ( glPauseTransformFeedbackNV != 0 )	++localInitializedProcCount;

		glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC) getExtensionPtr( "glResumeTransformFeedbackNV" );
		if ( glResumeTransformFeedbackNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_transform_feedback2 )

	if ( isGL_NV_transform_feedback2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_transform_feedback2                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_transform_feedback2                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_transform_feedback2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_transform_feedback2                         : not detected." );
	}


	isGL_NV_vdpau_interop = isExtensionSupported("GL_NV_vdpau_interop");

	localSupportedProcCount		= 10;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vdpau_interop ) // || isSEDEnable()
	{
		glVDPAUFiniNV = (PFNGLVDPAUFININVPROC) getExtensionPtr( "glVDPAUFiniNV" );
		if ( glVDPAUFiniNV != 0 )	++localInitializedProcCount;

		glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC) getExtensionPtr( "glVDPAUGetSurfaceivNV" );
		if ( glVDPAUGetSurfaceivNV != 0 )	++localInitializedProcCount;

		glVDPAUInitNV = (PFNGLVDPAUINITNVPROC) getExtensionPtr( "glVDPAUInitNV" );
		if ( glVDPAUInitNV != 0 )	++localInitializedProcCount;

		glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC) getExtensionPtr( "glVDPAUIsSurfaceNV" );
		if ( glVDPAUIsSurfaceNV != 0 )	++localInitializedProcCount;

		glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC) getExtensionPtr( "glVDPAUMapSurfacesNV" );
		if ( glVDPAUMapSurfacesNV != 0 )	++localInitializedProcCount;

		glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC) getExtensionPtr( "glVDPAURegisterOutputSurfaceNV" );
		if ( glVDPAURegisterOutputSurfaceNV != 0 )	++localInitializedProcCount;

		glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC) getExtensionPtr( "glVDPAURegisterVideoSurfaceNV" );
		if ( glVDPAURegisterVideoSurfaceNV != 0 )	++localInitializedProcCount;

		glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC) getExtensionPtr( "glVDPAUSurfaceAccessNV" );
		if ( glVDPAUSurfaceAccessNV != 0 )	++localInitializedProcCount;

		glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC) getExtensionPtr( "glVDPAUUnmapSurfacesNV" );
		if ( glVDPAUUnmapSurfacesNV != 0 )	++localInitializedProcCount;

		glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC) getExtensionPtr( "glVDPAUUnregisterSurfaceNV" );
		if ( glVDPAUUnregisterSurfaceNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_vdpau_interop )

	if ( isGL_NV_vdpau_interop )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vdpau_interop                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vdpau_interop                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vdpau_interop") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vdpau_interop                               : not detected." );
	}


	isGL_NV_vertex_array_range = isExtensionSupported("GL_NV_vertex_array_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_array_range ) // || isSEDEnable()
	{
		glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC) getExtensionPtr( "glFlushVertexArrayRangeNV" );
		if ( glFlushVertexArrayRangeNV != 0 )	++localInitializedProcCount;

		glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC) getExtensionPtr( "glVertexArrayRangeNV" );
		if ( glVertexArrayRangeNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_vertex_array_range )

	if ( isGL_NV_vertex_array_range )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_array_range                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_array_range                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_array_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_array_range                          : not detected." );
	}


	isGL_NV_vertex_array_range2 = isExtensionSupported("GL_NV_vertex_array_range2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_array_range2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_array_range2                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_array_range2                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_array_range2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_array_range2                         : not detected." );
	}


	isGL_NV_vertex_attrib_integer_64bit = isExtensionSupported("GL_NV_vertex_attrib_integer_64bit");

	localSupportedProcCount		= 19;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_attrib_integer_64bit ) // || isSEDEnable()
	{
		glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC) getExtensionPtr( "glGetVertexAttribLi64vNV" );
		if ( glGetVertexAttribLi64vNV != 0 )	++localInitializedProcCount;

		glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC) getExtensionPtr( "glGetVertexAttribLui64vNV" );
		if ( glGetVertexAttribLui64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC) getExtensionPtr( "glVertexAttribL1i64NV" );
		if ( glVertexAttribL1i64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC) getExtensionPtr( "glVertexAttribL1i64vNV" );
		if ( glVertexAttribL1i64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC) getExtensionPtr( "glVertexAttribL1ui64NV" );
		if ( glVertexAttribL1ui64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC) getExtensionPtr( "glVertexAttribL1ui64vNV" );
		if ( glVertexAttribL1ui64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC) getExtensionPtr( "glVertexAttribL2i64NV" );
		if ( glVertexAttribL2i64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC) getExtensionPtr( "glVertexAttribL2i64vNV" );
		if ( glVertexAttribL2i64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC) getExtensionPtr( "glVertexAttribL2ui64NV" );
		if ( glVertexAttribL2ui64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC) getExtensionPtr( "glVertexAttribL2ui64vNV" );
		if ( glVertexAttribL2ui64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC) getExtensionPtr( "glVertexAttribL3i64NV" );
		if ( glVertexAttribL3i64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC) getExtensionPtr( "glVertexAttribL3i64vNV" );
		if ( glVertexAttribL3i64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC) getExtensionPtr( "glVertexAttribL3ui64NV" );
		if ( glVertexAttribL3ui64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC) getExtensionPtr( "glVertexAttribL3ui64vNV" );
		if ( glVertexAttribL3ui64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC) getExtensionPtr( "glVertexAttribL4i64NV" );
		if ( glVertexAttribL4i64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC) getExtensionPtr( "glVertexAttribL4i64vNV" );
		if ( glVertexAttribL4i64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC) getExtensionPtr( "glVertexAttribL4ui64NV" );
		if ( glVertexAttribL4ui64NV != 0 )	++localInitializedProcCount;

		glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC) getExtensionPtr( "glVertexAttribL4ui64vNV" );
		if ( glVertexAttribL4ui64vNV != 0 )	++localInitializedProcCount;

		glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC) getExtensionPtr( "glVertexAttribLFormatNV" );
		if ( glVertexAttribLFormatNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_vertex_attrib_integer_64bit )

	if ( isGL_NV_vertex_attrib_integer_64bit )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_attrib_integer_64bit                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_attrib_integer_64bit                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_attrib_integer_64bit") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_attrib_integer_64bit                 : not detected." );
	}


	isGL_NV_vertex_buffer_unified_memory = isExtensionSupported("GL_NV_vertex_buffer_unified_memory");

	localSupportedProcCount		= 12;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_buffer_unified_memory ) // || isSEDEnable()
	{
		glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC) getExtensionPtr( "glBufferAddressRangeNV" );
		if ( glBufferAddressRangeNV != 0 )	++localInitializedProcCount;

		glColorFormatNV = (PFNGLCOLORFORMATNVPROC) getExtensionPtr( "glColorFormatNV" );
		if ( glColorFormatNV != 0 )	++localInitializedProcCount;

		glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC) getExtensionPtr( "glEdgeFlagFormatNV" );
		if ( glEdgeFlagFormatNV != 0 )	++localInitializedProcCount;

		glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC) getExtensionPtr( "glFogCoordFormatNV" );
		if ( glFogCoordFormatNV != 0 )	++localInitializedProcCount;

		glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC) getExtensionPtr( "glGetIntegerui64i_vNV" );
		if ( glGetIntegerui64i_vNV != 0 )	++localInitializedProcCount;

		glIndexFormatNV = (PFNGLINDEXFORMATNVPROC) getExtensionPtr( "glIndexFormatNV" );
		if ( glIndexFormatNV != 0 )	++localInitializedProcCount;

		glNormalFormatNV = (PFNGLNORMALFORMATNVPROC) getExtensionPtr( "glNormalFormatNV" );
		if ( glNormalFormatNV != 0 )	++localInitializedProcCount;

		glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC) getExtensionPtr( "glSecondaryColorFormatNV" );
		if ( glSecondaryColorFormatNV != 0 )	++localInitializedProcCount;

		glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC) getExtensionPtr( "glTexCoordFormatNV" );
		if ( glTexCoordFormatNV != 0 )	++localInitializedProcCount;

		glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC) getExtensionPtr( "glVertexAttribFormatNV" );
		if ( glVertexAttribFormatNV != 0 )	++localInitializedProcCount;

		glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC) getExtensionPtr( "glVertexAttribIFormatNV" );
		if ( glVertexAttribIFormatNV != 0 )	++localInitializedProcCount;

		glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC) getExtensionPtr( "glVertexFormatNV" );
		if ( glVertexFormatNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_vertex_buffer_unified_memory )

	if ( isGL_NV_vertex_buffer_unified_memory )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_buffer_unified_memory                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_buffer_unified_memory                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_buffer_unified_memory") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_buffer_unified_memory                : not detected." );
	}


	isGL_NV_vertex_program = isExtensionSupported("GL_NV_vertex_program");

	localSupportedProcCount		= 64;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_program ) // || isSEDEnable()
	{
		glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC) getExtensionPtr( "glAreProgramsResidentNV" );
		if ( glAreProgramsResidentNV != 0 )	++localInitializedProcCount;

		glBindProgramNV = (PFNGLBINDPROGRAMNVPROC) getExtensionPtr( "glBindProgramNV" );
		if ( glBindProgramNV != 0 )	++localInitializedProcCount;

		glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC) getExtensionPtr( "glDeleteProgramsNV" );
		if ( glDeleteProgramsNV != 0 )	++localInitializedProcCount;

		glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC) getExtensionPtr( "glExecuteProgramNV" );
		if ( glExecuteProgramNV != 0 )	++localInitializedProcCount;

		glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC) getExtensionPtr( "glGenProgramsNV" );
		if ( glGenProgramsNV != 0 )	++localInitializedProcCount;

		glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC) getExtensionPtr( "glGetProgramParameterdvNV" );
		if ( glGetProgramParameterdvNV != 0 )	++localInitializedProcCount;

		glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC) getExtensionPtr( "glGetProgramParameterfvNV" );
		if ( glGetProgramParameterfvNV != 0 )	++localInitializedProcCount;

		glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC) getExtensionPtr( "glGetProgramStringNV" );
		if ( glGetProgramStringNV != 0 )	++localInitializedProcCount;

		glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC) getExtensionPtr( "glGetProgramivNV" );
		if ( glGetProgramivNV != 0 )	++localInitializedProcCount;

		glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC) getExtensionPtr( "glGetTrackMatrixivNV" );
		if ( glGetTrackMatrixivNV != 0 )	++localInitializedProcCount;

		glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC) getExtensionPtr( "glGetVertexAttribPointervNV" );
		if ( glGetVertexAttribPointervNV != 0 )	++localInitializedProcCount;

		glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) getExtensionPtr( "glGetVertexAttribdvNV" );
		if ( glGetVertexAttribdvNV != 0 )	++localInitializedProcCount;

		glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) getExtensionPtr( "glGetVertexAttribfvNV" );
		if ( glGetVertexAttribfvNV != 0 )	++localInitializedProcCount;

		glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) getExtensionPtr( "glGetVertexAttribivNV" );
		if ( glGetVertexAttribivNV != 0 )	++localInitializedProcCount;

		glIsProgramNV = (PFNGLISPROGRAMNVPROC) getExtensionPtr( "glIsProgramNV" );
		if ( glIsProgramNV != 0 )	++localInitializedProcCount;

		glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC) getExtensionPtr( "glLoadProgramNV" );
		if ( glLoadProgramNV != 0 )	++localInitializedProcCount;

		glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC) getExtensionPtr( "glProgramParameter4dNV" );
		if ( glProgramParameter4dNV != 0 )	++localInitializedProcCount;

		glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC) getExtensionPtr( "glProgramParameter4dvNV" );
		if ( glProgramParameter4dvNV != 0 )	++localInitializedProcCount;

		glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC) getExtensionPtr( "glProgramParameter4fNV" );
		if ( glProgramParameter4fNV != 0 )	++localInitializedProcCount;

		glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC) getExtensionPtr( "glProgramParameter4fvNV" );
		if ( glProgramParameter4fvNV != 0 )	++localInitializedProcCount;

		glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC) getExtensionPtr( "glProgramParameters4dvNV" );
		if ( glProgramParameters4dvNV != 0 )	++localInitializedProcCount;

		glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC) getExtensionPtr( "glProgramParameters4fvNV" );
		if ( glProgramParameters4fvNV != 0 )	++localInitializedProcCount;

		glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC) getExtensionPtr( "glRequestResidentProgramsNV" );
		if ( glRequestResidentProgramsNV != 0 )	++localInitializedProcCount;

		glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC) getExtensionPtr( "glTrackMatrixNV" );
		if ( glTrackMatrixNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC) getExtensionPtr( "glVertexAttrib1dNV" );
		if ( glVertexAttrib1dNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC) getExtensionPtr( "glVertexAttrib1dvNV" );
		if ( glVertexAttrib1dvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC) getExtensionPtr( "glVertexAttrib1fNV" );
		if ( glVertexAttrib1fNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC) getExtensionPtr( "glVertexAttrib1fvNV" );
		if ( glVertexAttrib1fvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC) getExtensionPtr( "glVertexAttrib1sNV" );
		if ( glVertexAttrib1sNV != 0 )	++localInitializedProcCount;

		glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC) getExtensionPtr( "glVertexAttrib1svNV" );
		if ( glVertexAttrib1svNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC) getExtensionPtr( "glVertexAttrib2dNV" );
		if ( glVertexAttrib2dNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC) getExtensionPtr( "glVertexAttrib2dvNV" );
		if ( glVertexAttrib2dvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC) getExtensionPtr( "glVertexAttrib2fNV" );
		if ( glVertexAttrib2fNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC) getExtensionPtr( "glVertexAttrib2fvNV" );
		if ( glVertexAttrib2fvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) getExtensionPtr( "glVertexAttrib2sNV" );
		if ( glVertexAttrib2sNV != 0 )	++localInitializedProcCount;

		glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC) getExtensionPtr( "glVertexAttrib2svNV" );
		if ( glVertexAttrib2svNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC) getExtensionPtr( "glVertexAttrib3dNV" );
		if ( glVertexAttrib3dNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC) getExtensionPtr( "glVertexAttrib3dvNV" );
		if ( glVertexAttrib3dvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) getExtensionPtr( "glVertexAttrib3fNV" );
		if ( glVertexAttrib3fNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC) getExtensionPtr( "glVertexAttrib3fvNV" );
		if ( glVertexAttrib3fvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC) getExtensionPtr( "glVertexAttrib3sNV" );
		if ( glVertexAttrib3sNV != 0 )	++localInitializedProcCount;

		glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC) getExtensionPtr( "glVertexAttrib3svNV" );
		if ( glVertexAttrib3svNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC) getExtensionPtr( "glVertexAttrib4dNV" );
		if ( glVertexAttrib4dNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) getExtensionPtr( "glVertexAttrib4dvNV" );
		if ( glVertexAttrib4dvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC) getExtensionPtr( "glVertexAttrib4fNV" );
		if ( glVertexAttrib4fNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC) getExtensionPtr( "glVertexAttrib4fvNV" );
		if ( glVertexAttrib4fvNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC) getExtensionPtr( "glVertexAttrib4sNV" );
		if ( glVertexAttrib4sNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC) getExtensionPtr( "glVertexAttrib4svNV" );
		if ( glVertexAttrib4svNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC) getExtensionPtr( "glVertexAttrib4ubNV" );
		if ( glVertexAttrib4ubNV != 0 )	++localInitializedProcCount;

		glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC) getExtensionPtr( "glVertexAttrib4ubvNV" );
		if ( glVertexAttrib4ubvNV != 0 )	++localInitializedProcCount;

		glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC) getExtensionPtr( "glVertexAttribPointerNV" );
		if ( glVertexAttribPointerNV != 0 )	++localInitializedProcCount;

		glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC) getExtensionPtr( "glVertexAttribs1dvNV" );
		if ( glVertexAttribs1dvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC) getExtensionPtr( "glVertexAttribs1fvNV" );
		if ( glVertexAttribs1fvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC) getExtensionPtr( "glVertexAttribs1svNV" );
		if ( glVertexAttribs1svNV != 0 )	++localInitializedProcCount;

		glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC) getExtensionPtr( "glVertexAttribs2dvNV" );
		if ( glVertexAttribs2dvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC) getExtensionPtr( "glVertexAttribs2fvNV" );
		if ( glVertexAttribs2fvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC) getExtensionPtr( "glVertexAttribs2svNV" );
		if ( glVertexAttribs2svNV != 0 )	++localInitializedProcCount;

		glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC) getExtensionPtr( "glVertexAttribs3dvNV" );
		if ( glVertexAttribs3dvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC) getExtensionPtr( "glVertexAttribs3fvNV" );
		if ( glVertexAttribs3fvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC) getExtensionPtr( "glVertexAttribs3svNV" );
		if ( glVertexAttribs3svNV != 0 )	++localInitializedProcCount;

		glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC) getExtensionPtr( "glVertexAttribs4dvNV" );
		if ( glVertexAttribs4dvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC) getExtensionPtr( "glVertexAttribs4fvNV" );
		if ( glVertexAttribs4fvNV != 0 )	++localInitializedProcCount;

		glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC) getExtensionPtr( "glVertexAttribs4svNV" );
		if ( glVertexAttribs4svNV != 0 )	++localInitializedProcCount;

		glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC) getExtensionPtr( "glVertexAttribs4ubvNV" );
		if ( glVertexAttribs4ubvNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_vertex_program )

	if ( isGL_NV_vertex_program )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_program                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_program                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_program") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_program                              : not detected." );
	}


	isGL_NV_vertex_program1_1 = isExtensionSupported("GL_NV_vertex_program1_1");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_program1_1 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_program1_1                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_program1_1                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_program1_1") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_program1_1                           : not detected." );
	}


	isGL_NV_vertex_program2 = isExtensionSupported("GL_NV_vertex_program2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_program2 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_program2                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_program2                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_program2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_program2                             : not detected." );
	}


	isGL_NV_vertex_program2_option = isExtensionSupported("GL_NV_vertex_program2_option");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_program2_option )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_program2_option                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_program2_option                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_program2_option") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_program2_option                      : not detected." );
	}


	isGL_NV_vertex_program3 = isExtensionSupported("GL_NV_vertex_program3");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_program3 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_program3                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_program3                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_program3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_program3                             : not detected." );
	}


	isGL_NV_vertex_program4 = isExtensionSupported("GL_NV_vertex_program4");

	localSupportedProcCount		= 23;
	localInitializedProcCount	= 0;

	if ( isGL_NV_vertex_program4 ) // || isSEDEnable()
	{
		glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC) getExtensionPtr( "glGetVertexAttribIivEXT" );
		if ( glGetVertexAttribIivEXT != 0 )	++localInitializedProcCount;

		glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC) getExtensionPtr( "glGetVertexAttribIuivEXT" );
		if ( glGetVertexAttribIuivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC) getExtensionPtr( "glVertexAttribI1iEXT" );
		if ( glVertexAttribI1iEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC) getExtensionPtr( "glVertexAttribI1ivEXT" );
		if ( glVertexAttribI1ivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC) getExtensionPtr( "glVertexAttribI1uiEXT" );
		if ( glVertexAttribI1uiEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC) getExtensionPtr( "glVertexAttribI1uivEXT" );
		if ( glVertexAttribI1uivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC) getExtensionPtr( "glVertexAttribI2iEXT" );
		if ( glVertexAttribI2iEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC) getExtensionPtr( "glVertexAttribI2ivEXT" );
		if ( glVertexAttribI2ivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC) getExtensionPtr( "glVertexAttribI2uiEXT" );
		if ( glVertexAttribI2uiEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC) getExtensionPtr( "glVertexAttribI2uivEXT" );
		if ( glVertexAttribI2uivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC) getExtensionPtr( "glVertexAttribI3iEXT" );
		if ( glVertexAttribI3iEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC) getExtensionPtr( "glVertexAttribI3ivEXT" );
		if ( glVertexAttribI3ivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC) getExtensionPtr( "glVertexAttribI3uiEXT" );
		if ( glVertexAttribI3uiEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC) getExtensionPtr( "glVertexAttribI3uivEXT" );
		if ( glVertexAttribI3uivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC) getExtensionPtr( "glVertexAttribI4bvEXT" );
		if ( glVertexAttribI4bvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC) getExtensionPtr( "glVertexAttribI4iEXT" );
		if ( glVertexAttribI4iEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC) getExtensionPtr( "glVertexAttribI4ivEXT" );
		if ( glVertexAttribI4ivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC) getExtensionPtr( "glVertexAttribI4svEXT" );
		if ( glVertexAttribI4svEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC) getExtensionPtr( "glVertexAttribI4ubvEXT" );
		if ( glVertexAttribI4ubvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC) getExtensionPtr( "glVertexAttribI4uiEXT" );
		if ( glVertexAttribI4uiEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC) getExtensionPtr( "glVertexAttribI4uivEXT" );
		if ( glVertexAttribI4uivEXT != 0 )	++localInitializedProcCount;

		glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC) getExtensionPtr( "glVertexAttribI4usvEXT" );
		if ( glVertexAttribI4usvEXT != 0 )	++localInitializedProcCount;

		glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC) getExtensionPtr( "glVertexAttribIPointerEXT" );
		if ( glVertexAttribIPointerEXT != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_vertex_program4 )

	if ( isGL_NV_vertex_program4 )
	{
		std::stringstream strStream;
		strStream << "GL_NV_vertex_program4                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_vertex_program4                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_vertex_program4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_vertex_program4                             : not detected." );
	}


	isGL_NV_video_capture = isExtensionSupported("GL_NV_video_capture");

	localSupportedProcCount		= 12;
	localInitializedProcCount	= 0;

	if ( isGL_NV_video_capture ) // || isSEDEnable()
	{
		glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC) getExtensionPtr( "glBeginVideoCaptureNV" );
		if ( glBeginVideoCaptureNV != 0 )	++localInitializedProcCount;

		glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC) getExtensionPtr( "glBindVideoCaptureStreamBufferNV" );
		if ( glBindVideoCaptureStreamBufferNV != 0 )	++localInitializedProcCount;

		glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC) getExtensionPtr( "glBindVideoCaptureStreamTextureNV" );
		if ( glBindVideoCaptureStreamTextureNV != 0 )	++localInitializedProcCount;

		glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC) getExtensionPtr( "glEndVideoCaptureNV" );
		if ( glEndVideoCaptureNV != 0 )	++localInitializedProcCount;

		glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC) getExtensionPtr( "glGetVideoCaptureStreamdvNV" );
		if ( glGetVideoCaptureStreamdvNV != 0 )	++localInitializedProcCount;

		glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC) getExtensionPtr( "glGetVideoCaptureStreamfvNV" );
		if ( glGetVideoCaptureStreamfvNV != 0 )	++localInitializedProcCount;

		glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC) getExtensionPtr( "glGetVideoCaptureStreamivNV" );
		if ( glGetVideoCaptureStreamivNV != 0 )	++localInitializedProcCount;

		glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC) getExtensionPtr( "glGetVideoCaptureivNV" );
		if ( glGetVideoCaptureivNV != 0 )	++localInitializedProcCount;

		glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC) getExtensionPtr( "glVideoCaptureNV" );
		if ( glVideoCaptureNV != 0 )	++localInitializedProcCount;

		glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC) getExtensionPtr( "glVideoCaptureStreamParameterdvNV" );
		if ( glVideoCaptureStreamParameterdvNV != 0 )	++localInitializedProcCount;

		glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC) getExtensionPtr( "glVideoCaptureStreamParameterfvNV" );
		if ( glVideoCaptureStreamParameterfvNV != 0 )	++localInitializedProcCount;

		glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC) getExtensionPtr( "glVideoCaptureStreamParameterivNV" );
		if ( glVideoCaptureStreamParameterivNV != 0 )	++localInitializedProcCount;

	} // if ( isGL_NV_video_capture )

	if ( isGL_NV_video_capture )
	{
		std::stringstream strStream;
		strStream << "GL_NV_video_capture                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NV_video_capture                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NV_video_capture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NV_video_capture                               : not detected." );
	}


} // initializeGL_NV_video_capture()


void OpenGLExtensionsGen::initializeGL_NVX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_NVX_conditional_render = isExtensionSupported("GL_NVX_conditional_render");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_NVX_conditional_render ) // || isSEDEnable()
	{
		glBeginConditionalRenderNVX = (PFNGLBEGINCONDITIONALRENDERNVXPROC) getExtensionPtr( "glBeginConditionalRenderNVX" );
		if ( glBeginConditionalRenderNVX != 0 )	++localInitializedProcCount;

		glEndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC) getExtensionPtr( "glEndConditionalRenderNVX" );
		if ( glEndConditionalRenderNVX != 0 )	++localInitializedProcCount;

	} // if ( isGL_NVX_conditional_render )

	if ( isGL_NVX_conditional_render )
	{
		std::stringstream strStream;
		strStream << "GL_NVX_conditional_render                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_NVX_conditional_render                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_NVX_conditional_render") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_NVX_conditional_render                         : not detected." );
	}


} // initializeGL_NVX_conditional_render()


void OpenGLExtensionsGen::initializeGL_OES()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_OES_byte_coordinates = isExtensionSupported("GL_OES_byte_coordinates");

	localSupportedProcCount		= 22;
	localInitializedProcCount	= 0;

	if ( isGL_OES_byte_coordinates ) // || isSEDEnable()
	{
		glMultiTexCoord1bOES = (PFNGLMULTITEXCOORD1BOESPROC) getExtensionPtr( "glMultiTexCoord1bOES" );
		if ( glMultiTexCoord1bOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord1bvOES = (PFNGLMULTITEXCOORD1BVOESPROC) getExtensionPtr( "glMultiTexCoord1bvOES" );
		if ( glMultiTexCoord1bvOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord2bOES = (PFNGLMULTITEXCOORD2BOESPROC) getExtensionPtr( "glMultiTexCoord2bOES" );
		if ( glMultiTexCoord2bOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord2bvOES = (PFNGLMULTITEXCOORD2BVOESPROC) getExtensionPtr( "glMultiTexCoord2bvOES" );
		if ( glMultiTexCoord2bvOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord3bOES = (PFNGLMULTITEXCOORD3BOESPROC) getExtensionPtr( "glMultiTexCoord3bOES" );
		if ( glMultiTexCoord3bOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord3bvOES = (PFNGLMULTITEXCOORD3BVOESPROC) getExtensionPtr( "glMultiTexCoord3bvOES" );
		if ( glMultiTexCoord3bvOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord4bOES = (PFNGLMULTITEXCOORD4BOESPROC) getExtensionPtr( "glMultiTexCoord4bOES" );
		if ( glMultiTexCoord4bOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord4bvOES = (PFNGLMULTITEXCOORD4BVOESPROC) getExtensionPtr( "glMultiTexCoord4bvOES" );
		if ( glMultiTexCoord4bvOES != 0 )	++localInitializedProcCount;

		glTexCoord1bOES = (PFNGLTEXCOORD1BOESPROC) getExtensionPtr( "glTexCoord1bOES" );
		if ( glTexCoord1bOES != 0 )	++localInitializedProcCount;

		glTexCoord1bvOES = (PFNGLTEXCOORD1BVOESPROC) getExtensionPtr( "glTexCoord1bvOES" );
		if ( glTexCoord1bvOES != 0 )	++localInitializedProcCount;

		glTexCoord2bOES = (PFNGLTEXCOORD2BOESPROC) getExtensionPtr( "glTexCoord2bOES" );
		if ( glTexCoord2bOES != 0 )	++localInitializedProcCount;

		glTexCoord2bvOES = (PFNGLTEXCOORD2BVOESPROC) getExtensionPtr( "glTexCoord2bvOES" );
		if ( glTexCoord2bvOES != 0 )	++localInitializedProcCount;

		glTexCoord3bOES = (PFNGLTEXCOORD3BOESPROC) getExtensionPtr( "glTexCoord3bOES" );
		if ( glTexCoord3bOES != 0 )	++localInitializedProcCount;

		glTexCoord3bvOES = (PFNGLTEXCOORD3BVOESPROC) getExtensionPtr( "glTexCoord3bvOES" );
		if ( glTexCoord3bvOES != 0 )	++localInitializedProcCount;

		glTexCoord4bOES = (PFNGLTEXCOORD4BOESPROC) getExtensionPtr( "glTexCoord4bOES" );
		if ( glTexCoord4bOES != 0 )	++localInitializedProcCount;

		glTexCoord4bvOES = (PFNGLTEXCOORD4BVOESPROC) getExtensionPtr( "glTexCoord4bvOES" );
		if ( glTexCoord4bvOES != 0 )	++localInitializedProcCount;

		glVertex2bOES = (PFNGLVERTEX2BOESPROC) getExtensionPtr( "glVertex2bOES" );
		if ( glVertex2bOES != 0 )	++localInitializedProcCount;

		glVertex2bvOES = (PFNGLVERTEX2BVOESPROC) getExtensionPtr( "glVertex2bvOES" );
		if ( glVertex2bvOES != 0 )	++localInitializedProcCount;

		glVertex3bOES = (PFNGLVERTEX3BOESPROC) getExtensionPtr( "glVertex3bOES" );
		if ( glVertex3bOES != 0 )	++localInitializedProcCount;

		glVertex3bvOES = (PFNGLVERTEX3BVOESPROC) getExtensionPtr( "glVertex3bvOES" );
		if ( glVertex3bvOES != 0 )	++localInitializedProcCount;

		glVertex4bOES = (PFNGLVERTEX4BOESPROC) getExtensionPtr( "glVertex4bOES" );
		if ( glVertex4bOES != 0 )	++localInitializedProcCount;

		glVertex4bvOES = (PFNGLVERTEX4BVOESPROC) getExtensionPtr( "glVertex4bvOES" );
		if ( glVertex4bvOES != 0 )	++localInitializedProcCount;

	} // if ( isGL_OES_byte_coordinates )

	if ( isGL_OES_byte_coordinates )
	{
		std::stringstream strStream;
		strStream << "GL_OES_byte_coordinates                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OES_byte_coordinates                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OES_byte_coordinates") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OES_byte_coordinates                           : not detected." );
	}


	isGL_OES_compressed_paletted_texture = isExtensionSupported("GL_OES_compressed_paletted_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_OES_compressed_paletted_texture )
	{
		std::stringstream strStream;
		strStream << "GL_OES_compressed_paletted_texture                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OES_compressed_paletted_texture                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OES_compressed_paletted_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OES_compressed_paletted_texture                : not detected." );
	}


	isGL_OES_fixed_point = isExtensionSupported("GL_OES_fixed_point");

	localSupportedProcCount		= 104;
	localInitializedProcCount	= 0;

	if ( isGL_OES_fixed_point ) // || isSEDEnable()
	{
		glAccumxOES = (PFNGLACCUMXOESPROC) getExtensionPtr( "glAccumxOES" );
		if ( glAccumxOES != 0 )	++localInitializedProcCount;

		glAlphaFuncxOES = (PFNGLALPHAFUNCXOESPROC) getExtensionPtr( "glAlphaFuncxOES" );
		if ( glAlphaFuncxOES != 0 )	++localInitializedProcCount;

		glBitmapxOES = (PFNGLBITMAPXOESPROC) getExtensionPtr( "glBitmapxOES" );
		if ( glBitmapxOES != 0 )	++localInitializedProcCount;

		glBlendColorxOES = (PFNGLBLENDCOLORXOESPROC) getExtensionPtr( "glBlendColorxOES" );
		if ( glBlendColorxOES != 0 )	++localInitializedProcCount;

		glClearAccumxOES = (PFNGLCLEARACCUMXOESPROC) getExtensionPtr( "glClearAccumxOES" );
		if ( glClearAccumxOES != 0 )	++localInitializedProcCount;

		glClearColorxOES = (PFNGLCLEARCOLORXOESPROC) getExtensionPtr( "glClearColorxOES" );
		if ( glClearColorxOES != 0 )	++localInitializedProcCount;

		glClearDepthxOES = (PFNGLCLEARDEPTHXOESPROC) getExtensionPtr( "glClearDepthxOES" );
		if ( glClearDepthxOES != 0 )	++localInitializedProcCount;

		glClipPlanexOES = (PFNGLCLIPPLANEXOESPROC) getExtensionPtr( "glClipPlanexOES" );
		if ( glClipPlanexOES != 0 )	++localInitializedProcCount;

		glColor3xOES = (PFNGLCOLOR3XOESPROC) getExtensionPtr( "glColor3xOES" );
		if ( glColor3xOES != 0 )	++localInitializedProcCount;

		glColor3xvOES = (PFNGLCOLOR3XVOESPROC) getExtensionPtr( "glColor3xvOES" );
		if ( glColor3xvOES != 0 )	++localInitializedProcCount;

		glColor4xOES = (PFNGLCOLOR4XOESPROC) getExtensionPtr( "glColor4xOES" );
		if ( glColor4xOES != 0 )	++localInitializedProcCount;

		glColor4xvOES = (PFNGLCOLOR4XVOESPROC) getExtensionPtr( "glColor4xvOES" );
		if ( glColor4xvOES != 0 )	++localInitializedProcCount;

		glConvolutionParameterxOES = (PFNGLCONVOLUTIONPARAMETERXOESPROC) getExtensionPtr( "glConvolutionParameterxOES" );
		if ( glConvolutionParameterxOES != 0 )	++localInitializedProcCount;

		glConvolutionParameterxvOES = (PFNGLCONVOLUTIONPARAMETERXVOESPROC) getExtensionPtr( "glConvolutionParameterxvOES" );
		if ( glConvolutionParameterxvOES != 0 )	++localInitializedProcCount;

		glDepthRangexOES = (PFNGLDEPTHRANGEXOESPROC) getExtensionPtr( "glDepthRangexOES" );
		if ( glDepthRangexOES != 0 )	++localInitializedProcCount;

		glEvalCoord1xOES = (PFNGLEVALCOORD1XOESPROC) getExtensionPtr( "glEvalCoord1xOES" );
		if ( glEvalCoord1xOES != 0 )	++localInitializedProcCount;

		glEvalCoord1xvOES = (PFNGLEVALCOORD1XVOESPROC) getExtensionPtr( "glEvalCoord1xvOES" );
		if ( glEvalCoord1xvOES != 0 )	++localInitializedProcCount;

		glEvalCoord2xOES = (PFNGLEVALCOORD2XOESPROC) getExtensionPtr( "glEvalCoord2xOES" );
		if ( glEvalCoord2xOES != 0 )	++localInitializedProcCount;

		glEvalCoord2xvOES = (PFNGLEVALCOORD2XVOESPROC) getExtensionPtr( "glEvalCoord2xvOES" );
		if ( glEvalCoord2xvOES != 0 )	++localInitializedProcCount;

		glFeedbackBufferxOES = (PFNGLFEEDBACKBUFFERXOESPROC) getExtensionPtr( "glFeedbackBufferxOES" );
		if ( glFeedbackBufferxOES != 0 )	++localInitializedProcCount;

		glFogxOES = (PFNGLFOGXOESPROC) getExtensionPtr( "glFogxOES" );
		if ( glFogxOES != 0 )	++localInitializedProcCount;

		glFogxvOES = (PFNGLFOGXVOESPROC) getExtensionPtr( "glFogxvOES" );
		if ( glFogxvOES != 0 )	++localInitializedProcCount;

		glFrustumxOES = (PFNGLFRUSTUMXOESPROC) getExtensionPtr( "glFrustumxOES" );
		if ( glFrustumxOES != 0 )	++localInitializedProcCount;

		glGetClipPlanexOES = (PFNGLGETCLIPPLANEXOESPROC) getExtensionPtr( "glGetClipPlanexOES" );
		if ( glGetClipPlanexOES != 0 )	++localInitializedProcCount;

		glGetConvolutionParameterxvOES = (PFNGLGETCONVOLUTIONPARAMETERXVOESPROC) getExtensionPtr( "glGetConvolutionParameterxvOES" );
		if ( glGetConvolutionParameterxvOES != 0 )	++localInitializedProcCount;

		glGetFixedvOES = (PFNGLGETFIXEDVOESPROC) getExtensionPtr( "glGetFixedvOES" );
		if ( glGetFixedvOES != 0 )	++localInitializedProcCount;

		glGetHistogramParameterxvOES = (PFNGLGETHISTOGRAMPARAMETERXVOESPROC) getExtensionPtr( "glGetHistogramParameterxvOES" );
		if ( glGetHistogramParameterxvOES != 0 )	++localInitializedProcCount;

		glGetLightxOES = (PFNGLGETLIGHTXOESPROC) getExtensionPtr( "glGetLightxOES" );
		if ( glGetLightxOES != 0 )	++localInitializedProcCount;

		glGetMapxvOES = (PFNGLGETMAPXVOESPROC) getExtensionPtr( "glGetMapxvOES" );
		if ( glGetMapxvOES != 0 )	++localInitializedProcCount;

		glGetMaterialxOES = (PFNGLGETMATERIALXOESPROC) getExtensionPtr( "glGetMaterialxOES" );
		if ( glGetMaterialxOES != 0 )	++localInitializedProcCount;

		glGetPixelMapxv = (PFNGLGETPIXELMAPXVPROC) getExtensionPtr( "glGetPixelMapxv" );
		if ( glGetPixelMapxv != 0 )	++localInitializedProcCount;

		glGetTexEnvxvOES = (PFNGLGETTEXENVXVOESPROC) getExtensionPtr( "glGetTexEnvxvOES" );
		if ( glGetTexEnvxvOES != 0 )	++localInitializedProcCount;

		glGetTexGenxvOES = (PFNGLGETTEXGENXVOESPROC) getExtensionPtr( "glGetTexGenxvOES" );
		if ( glGetTexGenxvOES != 0 )	++localInitializedProcCount;

		glGetTexLevelParameterxvOES = (PFNGLGETTEXLEVELPARAMETERXVOESPROC) getExtensionPtr( "glGetTexLevelParameterxvOES" );
		if ( glGetTexLevelParameterxvOES != 0 )	++localInitializedProcCount;

		glGetTexParameterxvOES = (PFNGLGETTEXPARAMETERXVOESPROC) getExtensionPtr( "glGetTexParameterxvOES" );
		if ( glGetTexParameterxvOES != 0 )	++localInitializedProcCount;

		glIndexxOES = (PFNGLINDEXXOESPROC) getExtensionPtr( "glIndexxOES" );
		if ( glIndexxOES != 0 )	++localInitializedProcCount;

		glIndexxvOES = (PFNGLINDEXXVOESPROC) getExtensionPtr( "glIndexxvOES" );
		if ( glIndexxvOES != 0 )	++localInitializedProcCount;

		glLightModelxOES = (PFNGLLIGHTMODELXOESPROC) getExtensionPtr( "glLightModelxOES" );
		if ( glLightModelxOES != 0 )	++localInitializedProcCount;

		glLightModelxvOES = (PFNGLLIGHTMODELXVOESPROC) getExtensionPtr( "glLightModelxvOES" );
		if ( glLightModelxvOES != 0 )	++localInitializedProcCount;

		glLightxOES = (PFNGLLIGHTXOESPROC) getExtensionPtr( "glLightxOES" );
		if ( glLightxOES != 0 )	++localInitializedProcCount;

		glLightxvOES = (PFNGLLIGHTXVOESPROC) getExtensionPtr( "glLightxvOES" );
		if ( glLightxvOES != 0 )	++localInitializedProcCount;

		glLineWidthxOES = (PFNGLLINEWIDTHXOESPROC) getExtensionPtr( "glLineWidthxOES" );
		if ( glLineWidthxOES != 0 )	++localInitializedProcCount;

		glLoadMatrixxOES = (PFNGLLOADMATRIXXOESPROC) getExtensionPtr( "glLoadMatrixxOES" );
		if ( glLoadMatrixxOES != 0 )	++localInitializedProcCount;

		glLoadTransposeMatrixxOES = (PFNGLLOADTRANSPOSEMATRIXXOESPROC) getExtensionPtr( "glLoadTransposeMatrixxOES" );
		if ( glLoadTransposeMatrixxOES != 0 )	++localInitializedProcCount;

		glMap1xOES = (PFNGLMAP1XOESPROC) getExtensionPtr( "glMap1xOES" );
		if ( glMap1xOES != 0 )	++localInitializedProcCount;

		glMap2xOES = (PFNGLMAP2XOESPROC) getExtensionPtr( "glMap2xOES" );
		if ( glMap2xOES != 0 )	++localInitializedProcCount;

		glMapGrid1xOES = (PFNGLMAPGRID1XOESPROC) getExtensionPtr( "glMapGrid1xOES" );
		if ( glMapGrid1xOES != 0 )	++localInitializedProcCount;

		glMapGrid2xOES = (PFNGLMAPGRID2XOESPROC) getExtensionPtr( "glMapGrid2xOES" );
		if ( glMapGrid2xOES != 0 )	++localInitializedProcCount;

		glMaterialxOES = (PFNGLMATERIALXOESPROC) getExtensionPtr( "glMaterialxOES" );
		if ( glMaterialxOES != 0 )	++localInitializedProcCount;

		glMaterialxvOES = (PFNGLMATERIALXVOESPROC) getExtensionPtr( "glMaterialxvOES" );
		if ( glMaterialxvOES != 0 )	++localInitializedProcCount;

		glMultMatrixxOES = (PFNGLMULTMATRIXXOESPROC) getExtensionPtr( "glMultMatrixxOES" );
		if ( glMultMatrixxOES != 0 )	++localInitializedProcCount;

		glMultTransposeMatrixxOES = (PFNGLMULTTRANSPOSEMATRIXXOESPROC) getExtensionPtr( "glMultTransposeMatrixxOES" );
		if ( glMultTransposeMatrixxOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord1xOES = (PFNGLMULTITEXCOORD1XOESPROC) getExtensionPtr( "glMultiTexCoord1xOES" );
		if ( glMultiTexCoord1xOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord1xvOES = (PFNGLMULTITEXCOORD1XVOESPROC) getExtensionPtr( "glMultiTexCoord1xvOES" );
		if ( glMultiTexCoord1xvOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord2xOES = (PFNGLMULTITEXCOORD2XOESPROC) getExtensionPtr( "glMultiTexCoord2xOES" );
		if ( glMultiTexCoord2xOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord2xvOES = (PFNGLMULTITEXCOORD2XVOESPROC) getExtensionPtr( "glMultiTexCoord2xvOES" );
		if ( glMultiTexCoord2xvOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord3xOES = (PFNGLMULTITEXCOORD3XOESPROC) getExtensionPtr( "glMultiTexCoord3xOES" );
		if ( glMultiTexCoord3xOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord3xvOES = (PFNGLMULTITEXCOORD3XVOESPROC) getExtensionPtr( "glMultiTexCoord3xvOES" );
		if ( glMultiTexCoord3xvOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord4xOES = (PFNGLMULTITEXCOORD4XOESPROC) getExtensionPtr( "glMultiTexCoord4xOES" );
		if ( glMultiTexCoord4xOES != 0 )	++localInitializedProcCount;

		glMultiTexCoord4xvOES = (PFNGLMULTITEXCOORD4XVOESPROC) getExtensionPtr( "glMultiTexCoord4xvOES" );
		if ( glMultiTexCoord4xvOES != 0 )	++localInitializedProcCount;

		glNormal3xOES = (PFNGLNORMAL3XOESPROC) getExtensionPtr( "glNormal3xOES" );
		if ( glNormal3xOES != 0 )	++localInitializedProcCount;

		glNormal3xvOES = (PFNGLNORMAL3XVOESPROC) getExtensionPtr( "glNormal3xvOES" );
		if ( glNormal3xvOES != 0 )	++localInitializedProcCount;

		glOrthoxOES = (PFNGLORTHOXOESPROC) getExtensionPtr( "glOrthoxOES" );
		if ( glOrthoxOES != 0 )	++localInitializedProcCount;

		glPassThroughxOES = (PFNGLPASSTHROUGHXOESPROC) getExtensionPtr( "glPassThroughxOES" );
		if ( glPassThroughxOES != 0 )	++localInitializedProcCount;

		glPixelMapx = (PFNGLPIXELMAPXPROC) getExtensionPtr( "glPixelMapx" );
		if ( glPixelMapx != 0 )	++localInitializedProcCount;

		glPixelStorex = (PFNGLPIXELSTOREXPROC) getExtensionPtr( "glPixelStorex" );
		if ( glPixelStorex != 0 )	++localInitializedProcCount;

		glPixelTransferxOES = (PFNGLPIXELTRANSFERXOESPROC) getExtensionPtr( "glPixelTransferxOES" );
		if ( glPixelTransferxOES != 0 )	++localInitializedProcCount;

		glPixelZoomxOES = (PFNGLPIXELZOOMXOESPROC) getExtensionPtr( "glPixelZoomxOES" );
		if ( glPixelZoomxOES != 0 )	++localInitializedProcCount;

		glPointParameterxvOES = (PFNGLPOINTPARAMETERXVOESPROC) getExtensionPtr( "glPointParameterxvOES" );
		if ( glPointParameterxvOES != 0 )	++localInitializedProcCount;

		glPointSizexOES = (PFNGLPOINTSIZEXOESPROC) getExtensionPtr( "glPointSizexOES" );
		if ( glPointSizexOES != 0 )	++localInitializedProcCount;

		glPolygonOffsetxOES = (PFNGLPOLYGONOFFSETXOESPROC) getExtensionPtr( "glPolygonOffsetxOES" );
		if ( glPolygonOffsetxOES != 0 )	++localInitializedProcCount;

		glPrioritizeTexturesxOES = (PFNGLPRIORITIZETEXTURESXOESPROC) getExtensionPtr( "glPrioritizeTexturesxOES" );
		if ( glPrioritizeTexturesxOES != 0 )	++localInitializedProcCount;

		glRasterPos2xOES = (PFNGLRASTERPOS2XOESPROC) getExtensionPtr( "glRasterPos2xOES" );
		if ( glRasterPos2xOES != 0 )	++localInitializedProcCount;

		glRasterPos2xvOES = (PFNGLRASTERPOS2XVOESPROC) getExtensionPtr( "glRasterPos2xvOES" );
		if ( glRasterPos2xvOES != 0 )	++localInitializedProcCount;

		glRasterPos3xOES = (PFNGLRASTERPOS3XOESPROC) getExtensionPtr( "glRasterPos3xOES" );
		if ( glRasterPos3xOES != 0 )	++localInitializedProcCount;

		glRasterPos3xvOES = (PFNGLRASTERPOS3XVOESPROC) getExtensionPtr( "glRasterPos3xvOES" );
		if ( glRasterPos3xvOES != 0 )	++localInitializedProcCount;

		glRasterPos4xOES = (PFNGLRASTERPOS4XOESPROC) getExtensionPtr( "glRasterPos4xOES" );
		if ( glRasterPos4xOES != 0 )	++localInitializedProcCount;

		glRasterPos4xvOES = (PFNGLRASTERPOS4XVOESPROC) getExtensionPtr( "glRasterPos4xvOES" );
		if ( glRasterPos4xvOES != 0 )	++localInitializedProcCount;

		glRectxOES = (PFNGLRECTXOESPROC) getExtensionPtr( "glRectxOES" );
		if ( glRectxOES != 0 )	++localInitializedProcCount;

		glRectxvOES = (PFNGLRECTXVOESPROC) getExtensionPtr( "glRectxvOES" );
		if ( glRectxvOES != 0 )	++localInitializedProcCount;

		glRotatexOES = (PFNGLROTATEXOESPROC) getExtensionPtr( "glRotatexOES" );
		if ( glRotatexOES != 0 )	++localInitializedProcCount;

		glSampleCoverageOES = (PFNGLSAMPLECOVERAGEOESPROC) getExtensionPtr( "glSampleCoverageOES" );
		if ( glSampleCoverageOES != 0 )	++localInitializedProcCount;

		glScalexOES = (PFNGLSCALEXOESPROC) getExtensionPtr( "glScalexOES" );
		if ( glScalexOES != 0 )	++localInitializedProcCount;

		glTexCoord1xOES = (PFNGLTEXCOORD1XOESPROC) getExtensionPtr( "glTexCoord1xOES" );
		if ( glTexCoord1xOES != 0 )	++localInitializedProcCount;

		glTexCoord1xvOES = (PFNGLTEXCOORD1XVOESPROC) getExtensionPtr( "glTexCoord1xvOES" );
		if ( glTexCoord1xvOES != 0 )	++localInitializedProcCount;

		glTexCoord2xOES = (PFNGLTEXCOORD2XOESPROC) getExtensionPtr( "glTexCoord2xOES" );
		if ( glTexCoord2xOES != 0 )	++localInitializedProcCount;

		glTexCoord2xvOES = (PFNGLTEXCOORD2XVOESPROC) getExtensionPtr( "glTexCoord2xvOES" );
		if ( glTexCoord2xvOES != 0 )	++localInitializedProcCount;

		glTexCoord3xOES = (PFNGLTEXCOORD3XOESPROC) getExtensionPtr( "glTexCoord3xOES" );
		if ( glTexCoord3xOES != 0 )	++localInitializedProcCount;

		glTexCoord3xvOES = (PFNGLTEXCOORD3XVOESPROC) getExtensionPtr( "glTexCoord3xvOES" );
		if ( glTexCoord3xvOES != 0 )	++localInitializedProcCount;

		glTexCoord4xOES = (PFNGLTEXCOORD4XOESPROC) getExtensionPtr( "glTexCoord4xOES" );
		if ( glTexCoord4xOES != 0 )	++localInitializedProcCount;

		glTexCoord4xvOES = (PFNGLTEXCOORD4XVOESPROC) getExtensionPtr( "glTexCoord4xvOES" );
		if ( glTexCoord4xvOES != 0 )	++localInitializedProcCount;

		glTexEnvxOES = (PFNGLTEXENVXOESPROC) getExtensionPtr( "glTexEnvxOES" );
		if ( glTexEnvxOES != 0 )	++localInitializedProcCount;

		glTexEnvxvOES = (PFNGLTEXENVXVOESPROC) getExtensionPtr( "glTexEnvxvOES" );
		if ( glTexEnvxvOES != 0 )	++localInitializedProcCount;

		glTexGenxOES = (PFNGLTEXGENXOESPROC) getExtensionPtr( "glTexGenxOES" );
		if ( glTexGenxOES != 0 )	++localInitializedProcCount;

		glTexGenxvOES = (PFNGLTEXGENXVOESPROC) getExtensionPtr( "glTexGenxvOES" );
		if ( glTexGenxvOES != 0 )	++localInitializedProcCount;

		glTexParameterxOES = (PFNGLTEXPARAMETERXOESPROC) getExtensionPtr( "glTexParameterxOES" );
		if ( glTexParameterxOES != 0 )	++localInitializedProcCount;

		glTexParameterxvOES = (PFNGLTEXPARAMETERXVOESPROC) getExtensionPtr( "glTexParameterxvOES" );
		if ( glTexParameterxvOES != 0 )	++localInitializedProcCount;

		glTranslatexOES = (PFNGLTRANSLATEXOESPROC) getExtensionPtr( "glTranslatexOES" );
		if ( glTranslatexOES != 0 )	++localInitializedProcCount;

		glVertex2xOES = (PFNGLVERTEX2XOESPROC) getExtensionPtr( "glVertex2xOES" );
		if ( glVertex2xOES != 0 )	++localInitializedProcCount;

		glVertex2xvOES = (PFNGLVERTEX2XVOESPROC) getExtensionPtr( "glVertex2xvOES" );
		if ( glVertex2xvOES != 0 )	++localInitializedProcCount;

		glVertex3xOES = (PFNGLVERTEX3XOESPROC) getExtensionPtr( "glVertex3xOES" );
		if ( glVertex3xOES != 0 )	++localInitializedProcCount;

		glVertex3xvOES = (PFNGLVERTEX3XVOESPROC) getExtensionPtr( "glVertex3xvOES" );
		if ( glVertex3xvOES != 0 )	++localInitializedProcCount;

		glVertex4xOES = (PFNGLVERTEX4XOESPROC) getExtensionPtr( "glVertex4xOES" );
		if ( glVertex4xOES != 0 )	++localInitializedProcCount;

		glVertex4xvOES = (PFNGLVERTEX4XVOESPROC) getExtensionPtr( "glVertex4xvOES" );
		if ( glVertex4xvOES != 0 )	++localInitializedProcCount;

	} // if ( isGL_OES_fixed_point )

	if ( isGL_OES_fixed_point )
	{
		std::stringstream strStream;
		strStream << "GL_OES_fixed_point                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OES_fixed_point                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OES_fixed_point") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OES_fixed_point                                : not detected." );
	}


	isGL_OES_query_matrix = isExtensionSupported("GL_OES_query_matrix");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_OES_query_matrix ) // || isSEDEnable()
	{
		glQueryMatrixxOES = (PFNGLQUERYMATRIXXOESPROC) getExtensionPtr( "glQueryMatrixxOES" );
		if ( glQueryMatrixxOES != 0 )	++localInitializedProcCount;

	} // if ( isGL_OES_query_matrix )

	if ( isGL_OES_query_matrix )
	{
		std::stringstream strStream;
		strStream << "GL_OES_query_matrix                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OES_query_matrix                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OES_query_matrix") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OES_query_matrix                               : not detected." );
	}


	isGL_OES_read_format = isExtensionSupported("GL_OES_read_format");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_OES_read_format )
	{
		std::stringstream strStream;
		strStream << "GL_OES_read_format                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OES_read_format                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OES_read_format") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OES_read_format                                : not detected." );
	}


	isGL_OES_single_precision = isExtensionSupported("GL_OES_single_precision");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_OES_single_precision ) // || isSEDEnable()
	{
		glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC) getExtensionPtr( "glClearDepthfOES" );
		if ( glClearDepthfOES != 0 )	++localInitializedProcCount;

		glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC) getExtensionPtr( "glClipPlanefOES" );
		if ( glClipPlanefOES != 0 )	++localInitializedProcCount;

		glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC) getExtensionPtr( "glDepthRangefOES" );
		if ( glDepthRangefOES != 0 )	++localInitializedProcCount;

		glFrustumfOES = (PFNGLFRUSTUMFOESPROC) getExtensionPtr( "glFrustumfOES" );
		if ( glFrustumfOES != 0 )	++localInitializedProcCount;

		glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC) getExtensionPtr( "glGetClipPlanefOES" );
		if ( glGetClipPlanefOES != 0 )	++localInitializedProcCount;

		glOrthofOES = (PFNGLORTHOFOESPROC) getExtensionPtr( "glOrthofOES" );
		if ( glOrthofOES != 0 )	++localInitializedProcCount;

	} // if ( isGL_OES_single_precision )

	if ( isGL_OES_single_precision )
	{
		std::stringstream strStream;
		strStream << "GL_OES_single_precision                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OES_single_precision                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OES_single_precision") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OES_single_precision                           : not detected." );
	}


} // initializeGL_OES_single_precision()


void OpenGLExtensionsGen::initializeGL_OML()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_OML_interlace = isExtensionSupported("GL_OML_interlace");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_OML_interlace )
	{
		std::stringstream strStream;
		strStream << "GL_OML_interlace                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OML_interlace                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OML_interlace") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OML_interlace                                  : not detected." );
	}


	isGL_OML_resample = isExtensionSupported("GL_OML_resample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_OML_resample )
	{
		std::stringstream strStream;
		strStream << "GL_OML_resample                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OML_resample                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OML_resample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OML_resample                                   : not detected." );
	}


	isGL_OML_subsample = isExtensionSupported("GL_OML_subsample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_OML_subsample )
	{
		std::stringstream strStream;
		strStream << "GL_OML_subsample                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_OML_subsample                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_OML_subsample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_OML_subsample                                  : not detected." );
	}


} // initializeGL_OML_subsample()


void OpenGLExtensionsGen::initializeGL_PGI()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_PGI_misc_hints = isExtensionSupported("GL_PGI_misc_hints");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_PGI_misc_hints ) // || isSEDEnable()
	{
		glHintPGI = (PFNGLHINTPGIPROC) getExtensionPtr( "glHintPGI" );
		if ( glHintPGI != 0 )	++localInitializedProcCount;

	} // if ( isGL_PGI_misc_hints )

	if ( isGL_PGI_misc_hints )
	{
		std::stringstream strStream;
		strStream << "GL_PGI_misc_hints                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_PGI_misc_hints                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_PGI_misc_hints") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_PGI_misc_hints                                 : not detected." );
	}


	isGL_PGI_vertex_hints = isExtensionSupported("GL_PGI_vertex_hints");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_PGI_vertex_hints )
	{
		std::stringstream strStream;
		strStream << "GL_PGI_vertex_hints                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_PGI_vertex_hints                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_PGI_vertex_hints") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_PGI_vertex_hints                               : not detected." );
	}


} // initializeGL_PGI_vertex_hints()


void OpenGLExtensionsGen::initializeGL_REND()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_REND_screen_coordinates = isExtensionSupported("GL_REND_screen_coordinates");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_REND_screen_coordinates )
	{
		std::stringstream strStream;
		strStream << "GL_REND_screen_coordinates                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_REND_screen_coordinates                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_REND_screen_coordinates") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_REND_screen_coordinates                        : not detected." );
	}


} // initializeGL_REND_screen_coordinates()


void OpenGLExtensionsGen::initializeGL_S3()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_S3_s3tc = isExtensionSupported("GL_S3_s3tc");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_S3_s3tc )
	{
		std::stringstream strStream;
		strStream << "GL_S3_s3tc                                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_S3_s3tc                                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_S3_s3tc") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_S3_s3tc                                        : not detected." );
	}


} // initializeGL_S3_s3tc()


void OpenGLExtensionsGen::initializeGL_SGI()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_SGI_color_matrix = isExtensionSupported("GL_SGI_color_matrix");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGI_color_matrix )
	{
		std::stringstream strStream;
		strStream << "GL_SGI_color_matrix                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGI_color_matrix                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGI_color_matrix") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGI_color_matrix                               : not detected." );
	}


	isGL_SGI_color_table = isExtensionSupported("GL_SGI_color_table");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_SGI_color_table ) // || isSEDEnable()
	{
		glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC) getExtensionPtr( "glColorTableParameterfvSGI" );
		if ( glColorTableParameterfvSGI != 0 )	++localInitializedProcCount;

		glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC) getExtensionPtr( "glColorTableParameterivSGI" );
		if ( glColorTableParameterivSGI != 0 )	++localInitializedProcCount;

		glColorTableSGI = (PFNGLCOLORTABLESGIPROC) getExtensionPtr( "glColorTableSGI" );
		if ( glColorTableSGI != 0 )	++localInitializedProcCount;

		glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC) getExtensionPtr( "glCopyColorTableSGI" );
		if ( glCopyColorTableSGI != 0 )	++localInitializedProcCount;

		glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) getExtensionPtr( "glGetColorTableParameterfvSGI" );
		if ( glGetColorTableParameterfvSGI != 0 )	++localInitializedProcCount;

		glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) getExtensionPtr( "glGetColorTableParameterivSGI" );
		if ( glGetColorTableParameterivSGI != 0 )	++localInitializedProcCount;

		glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC) getExtensionPtr( "glGetColorTableSGI" );
		if ( glGetColorTableSGI != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGI_color_table )

	if ( isGL_SGI_color_table )
	{
		std::stringstream strStream;
		strStream << "GL_SGI_color_table                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGI_color_table                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGI_color_table") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGI_color_table                                : not detected." );
	}


	isGL_SGI_depth_pass_instrument = isExtensionSupported("GL_SGI_depth_pass_instrument");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGI_depth_pass_instrument )
	{
		std::stringstream strStream;
		strStream << "GL_SGI_depth_pass_instrument                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGI_depth_pass_instrument                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGI_depth_pass_instrument") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGI_depth_pass_instrument                      : not detected." );
	}


	isGL_SGI_texture_color_table = isExtensionSupported("GL_SGI_texture_color_table");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGI_texture_color_table )
	{
		std::stringstream strStream;
		strStream << "GL_SGI_texture_color_table                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGI_texture_color_table                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGI_texture_color_table") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGI_texture_color_table                        : not detected." );
	}


} // initializeGL_SGI_texture_color_table()


void OpenGLExtensionsGen::initializeGL_SGIS()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_SGIS_detail_texture = isExtensionSupported("GL_SGIS_detail_texture");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_detail_texture ) // || isSEDEnable()
	{
		glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC) getExtensionPtr( "glDetailTexFuncSGIS" );
		if ( glDetailTexFuncSGIS != 0 )	++localInitializedProcCount;

		glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC) getExtensionPtr( "glGetDetailTexFuncSGIS" );
		if ( glGetDetailTexFuncSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_detail_texture )

	if ( isGL_SGIS_detail_texture )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_detail_texture                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_detail_texture                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_detail_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_detail_texture                            : not detected." );
	}


	isGL_SGIS_fog_function = isExtensionSupported("GL_SGIS_fog_function");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_fog_function ) // || isSEDEnable()
	{
		glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC) getExtensionPtr( "glFogFuncSGIS" );
		if ( glFogFuncSGIS != 0 )	++localInitializedProcCount;

		glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC) getExtensionPtr( "glGetFogFuncSGIS" );
		if ( glGetFogFuncSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_fog_function )

	if ( isGL_SGIS_fog_function )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_fog_function                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_fog_function                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_fog_function") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_fog_function                              : not detected." );
	}


	isGL_SGIS_generate_mipmap = isExtensionSupported("GL_SGIS_generate_mipmap");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_generate_mipmap )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_generate_mipmap                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_generate_mipmap                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_generate_mipmap") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_generate_mipmap                           : not detected." );
	}


	isGL_SGIS_multisample = isExtensionSupported("GL_SGIS_multisample");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_multisample ) // || isSEDEnable()
	{
		glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC) getExtensionPtr( "glSampleMaskSGIS" );
		if ( glSampleMaskSGIS != 0 )	++localInitializedProcCount;

		glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC) getExtensionPtr( "glSamplePatternSGIS" );
		if ( glSamplePatternSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_multisample )

	if ( isGL_SGIS_multisample )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_multisample                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_multisample                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_multisample                               : not detected." );
	}


	isGL_SGIS_pixel_texture = isExtensionSupported("GL_SGIS_pixel_texture");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_pixel_texture ) // || isSEDEnable()
	{
		glGetPixelTexGenParameterfvSGIS = (PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) getExtensionPtr( "glGetPixelTexGenParameterfvSGIS" );
		if ( glGetPixelTexGenParameterfvSGIS != 0 )	++localInitializedProcCount;

		glGetPixelTexGenParameterivSGIS = (PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) getExtensionPtr( "glGetPixelTexGenParameterivSGIS" );
		if ( glGetPixelTexGenParameterivSGIS != 0 )	++localInitializedProcCount;

		glPixelTexGenParameterfSGIS = (PFNGLPIXELTEXGENPARAMETERFSGISPROC) getExtensionPtr( "glPixelTexGenParameterfSGIS" );
		if ( glPixelTexGenParameterfSGIS != 0 )	++localInitializedProcCount;

		glPixelTexGenParameterfvSGIS = (PFNGLPIXELTEXGENPARAMETERFVSGISPROC) getExtensionPtr( "glPixelTexGenParameterfvSGIS" );
		if ( glPixelTexGenParameterfvSGIS != 0 )	++localInitializedProcCount;

		glPixelTexGenParameteriSGIS = (PFNGLPIXELTEXGENPARAMETERISGISPROC) getExtensionPtr( "glPixelTexGenParameteriSGIS" );
		if ( glPixelTexGenParameteriSGIS != 0 )	++localInitializedProcCount;

		glPixelTexGenParameterivSGIS = (PFNGLPIXELTEXGENPARAMETERIVSGISPROC) getExtensionPtr( "glPixelTexGenParameterivSGIS" );
		if ( glPixelTexGenParameterivSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_pixel_texture )

	if ( isGL_SGIS_pixel_texture )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_pixel_texture                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_pixel_texture                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_pixel_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_pixel_texture                             : not detected." );
	}


	isGL_SGIS_point_line_texgen = isExtensionSupported("GL_SGIS_point_line_texgen");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_point_line_texgen )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_point_line_texgen                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_point_line_texgen                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_point_line_texgen") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_point_line_texgen                         : not detected." );
	}


	isGL_SGIS_point_parameters = isExtensionSupported("GL_SGIS_point_parameters");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_point_parameters ) // || isSEDEnable()
	{
		glPointParameterfSGIS = (PFNGLPOINTPARAMETERFSGISPROC) getExtensionPtr( "glPointParameterfSGIS" );
		if ( glPointParameterfSGIS != 0 )	++localInitializedProcCount;

		glPointParameterfvSGIS = (PFNGLPOINTPARAMETERFVSGISPROC) getExtensionPtr( "glPointParameterfvSGIS" );
		if ( glPointParameterfvSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_point_parameters )

	if ( isGL_SGIS_point_parameters )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_point_parameters                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_point_parameters                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_point_parameters") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_point_parameters                          : not detected." );
	}


	isGL_SGIS_sharpen_texture = isExtensionSupported("GL_SGIS_sharpen_texture");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_sharpen_texture ) // || isSEDEnable()
	{
		glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC) getExtensionPtr( "glGetSharpenTexFuncSGIS" );
		if ( glGetSharpenTexFuncSGIS != 0 )	++localInitializedProcCount;

		glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC) getExtensionPtr( "glSharpenTexFuncSGIS" );
		if ( glSharpenTexFuncSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_sharpen_texture )

	if ( isGL_SGIS_sharpen_texture )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_sharpen_texture                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_sharpen_texture                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_sharpen_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_sharpen_texture                           : not detected." );
	}


	isGL_SGIS_texture4D = isExtensionSupported("GL_SGIS_texture4D");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture4D ) // || isSEDEnable()
	{
		glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC) getExtensionPtr( "glTexImage4DSGIS" );
		if ( glTexImage4DSGIS != 0 )	++localInitializedProcCount;

		glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC) getExtensionPtr( "glTexSubImage4DSGIS" );
		if ( glTexSubImage4DSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_texture4D )

	if ( isGL_SGIS_texture4D )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture4D                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture4D                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture4D") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture4D                                 : not detected." );
	}


	isGL_SGIS_texture_border_clamp = isExtensionSupported("GL_SGIS_texture_border_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture_border_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture_border_clamp                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture_border_clamp                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture_border_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture_border_clamp                      : not detected." );
	}


	isGL_SGIS_texture_color_mask = isExtensionSupported("GL_SGIS_texture_color_mask");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture_color_mask ) // || isSEDEnable()
	{
		glTextureColorMaskSGIS = (PFNGLTEXTURECOLORMASKSGISPROC) getExtensionPtr( "glTextureColorMaskSGIS" );
		if ( glTextureColorMaskSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_texture_color_mask )

	if ( isGL_SGIS_texture_color_mask )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture_color_mask                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture_color_mask                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture_color_mask") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture_color_mask                        : not detected." );
	}


	isGL_SGIS_texture_edge_clamp = isExtensionSupported("GL_SGIS_texture_edge_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture_edge_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture_edge_clamp                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture_edge_clamp                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture_edge_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture_edge_clamp                        : not detected." );
	}


	isGL_SGIS_texture_filter4 = isExtensionSupported("GL_SGIS_texture_filter4");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture_filter4 ) // || isSEDEnable()
	{
		glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC) getExtensionPtr( "glGetTexFilterFuncSGIS" );
		if ( glGetTexFilterFuncSGIS != 0 )	++localInitializedProcCount;

		glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC) getExtensionPtr( "glTexFilterFuncSGIS" );
		if ( glTexFilterFuncSGIS != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIS_texture_filter4 )

	if ( isGL_SGIS_texture_filter4 )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture_filter4                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture_filter4                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture_filter4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture_filter4                           : not detected." );
	}


	isGL_SGIS_texture_lod = isExtensionSupported("GL_SGIS_texture_lod");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture_lod )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture_lod                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture_lod                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture_lod") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture_lod                               : not detected." );
	}


	isGL_SGIS_texture_select = isExtensionSupported("GL_SGIS_texture_select");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIS_texture_select )
	{
		std::stringstream strStream;
		strStream << "GL_SGIS_texture_select                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIS_texture_select                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIS_texture_select") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIS_texture_select                            : not detected." );
	}


} // initializeGL_SGIS_texture_select()


void OpenGLExtensionsGen::initializeGL_SGIX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_SGIX_async = isExtensionSupported("GL_SGIX_async");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_async ) // || isSEDEnable()
	{
		glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC) getExtensionPtr( "glAsyncMarkerSGIX" );
		if ( glAsyncMarkerSGIX != 0 )	++localInitializedProcCount;

		glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC) getExtensionPtr( "glDeleteAsyncMarkersSGIX" );
		if ( glDeleteAsyncMarkersSGIX != 0 )	++localInitializedProcCount;

		glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC) getExtensionPtr( "glFinishAsyncSGIX" );
		if ( glFinishAsyncSGIX != 0 )	++localInitializedProcCount;

		glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC) getExtensionPtr( "glGenAsyncMarkersSGIX" );
		if ( glGenAsyncMarkersSGIX != 0 )	++localInitializedProcCount;

		glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC) getExtensionPtr( "glIsAsyncMarkerSGIX" );
		if ( glIsAsyncMarkerSGIX != 0 )	++localInitializedProcCount;

		glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC) getExtensionPtr( "glPollAsyncSGIX" );
		if ( glPollAsyncSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_async )

	if ( isGL_SGIX_async )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_async                                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_async                                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_async") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_async                                     : not detected." );
	}


	isGL_SGIX_async_histogram = isExtensionSupported("GL_SGIX_async_histogram");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_async_histogram )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_async_histogram                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_async_histogram                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_async_histogram") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_async_histogram                           : not detected." );
	}


	isGL_SGIX_async_pixel = isExtensionSupported("GL_SGIX_async_pixel");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_async_pixel )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_async_pixel                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_async_pixel                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_async_pixel") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_async_pixel                               : not detected." );
	}


	isGL_SGIX_blend_alpha_minmax = isExtensionSupported("GL_SGIX_blend_alpha_minmax");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_blend_alpha_minmax )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_blend_alpha_minmax                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_blend_alpha_minmax                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_blend_alpha_minmax") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_blend_alpha_minmax                        : not detected." );
	}


	isGL_SGIX_calligraphic_fragment = isExtensionSupported("GL_SGIX_calligraphic_fragment");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_calligraphic_fragment )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_calligraphic_fragment                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_calligraphic_fragment                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_calligraphic_fragment") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_calligraphic_fragment                     : not detected." );
	}


	isGL_SGIX_clipmap = isExtensionSupported("GL_SGIX_clipmap");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_clipmap )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_clipmap                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_clipmap                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_clipmap") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_clipmap                                   : not detected." );
	}


	isGL_SGIX_convolution_accuracy = isExtensionSupported("GL_SGIX_convolution_accuracy");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_convolution_accuracy )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_convolution_accuracy                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_convolution_accuracy                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_convolution_accuracy") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_convolution_accuracy                      : not detected." );
	}


	isGL_SGIX_depth_pass_instrument = isExtensionSupported("GL_SGIX_depth_pass_instrument");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_depth_pass_instrument )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_depth_pass_instrument                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_depth_pass_instrument                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_depth_pass_instrument") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_depth_pass_instrument                     : not detected." );
	}


	isGL_SGIX_depth_texture = isExtensionSupported("GL_SGIX_depth_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_depth_texture )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_depth_texture                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_depth_texture                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_depth_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_depth_texture                             : not detected." );
	}


	isGL_SGIX_flush_raster = isExtensionSupported("GL_SGIX_flush_raster");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_flush_raster ) // || isSEDEnable()
	{
		glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC) getExtensionPtr( "glFlushRasterSGIX" );
		if ( glFlushRasterSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_flush_raster )

	if ( isGL_SGIX_flush_raster )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_flush_raster                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_flush_raster                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_flush_raster") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_flush_raster                              : not detected." );
	}


	isGL_SGIX_fog_offset = isExtensionSupported("GL_SGIX_fog_offset");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_fog_offset )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_fog_offset                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_fog_offset                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_fog_offset") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_fog_offset                                : not detected." );
	}


	isGL_SGIX_fog_scale = isExtensionSupported("GL_SGIX_fog_scale");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_fog_scale )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_fog_scale                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_fog_scale                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_fog_scale") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_fog_scale                                 : not detected." );
	}


	isGL_SGIX_fragment_lighting = isExtensionSupported("GL_SGIX_fragment_lighting");

	localSupportedProcCount		= 18;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_fragment_lighting ) // || isSEDEnable()
	{
		glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC) getExtensionPtr( "glFragmentColorMaterialSGIX" );
		if ( glFragmentColorMaterialSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC) getExtensionPtr( "glFragmentLightModelfSGIX" );
		if ( glFragmentLightModelfSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) getExtensionPtr( "glFragmentLightModelfvSGIX" );
		if ( glFragmentLightModelfvSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC) getExtensionPtr( "glFragmentLightModeliSGIX" );
		if ( glFragmentLightModeliSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) getExtensionPtr( "glFragmentLightModelivSGIX" );
		if ( glFragmentLightModelivSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC) getExtensionPtr( "glFragmentLightfSGIX" );
		if ( glFragmentLightfSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC) getExtensionPtr( "glFragmentLightfvSGIX" );
		if ( glFragmentLightfvSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC) getExtensionPtr( "glFragmentLightiSGIX" );
		if ( glFragmentLightiSGIX != 0 )	++localInitializedProcCount;

		glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC) getExtensionPtr( "glFragmentLightivSGIX" );
		if ( glFragmentLightivSGIX != 0 )	++localInitializedProcCount;

		glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC) getExtensionPtr( "glFragmentMaterialfSGIX" );
		if ( glFragmentMaterialfSGIX != 0 )	++localInitializedProcCount;

		glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC) getExtensionPtr( "glFragmentMaterialfvSGIX" );
		if ( glFragmentMaterialfvSGIX != 0 )	++localInitializedProcCount;

		glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC) getExtensionPtr( "glFragmentMaterialiSGIX" );
		if ( glFragmentMaterialiSGIX != 0 )	++localInitializedProcCount;

		glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC) getExtensionPtr( "glFragmentMaterialivSGIX" );
		if ( glFragmentMaterialivSGIX != 0 )	++localInitializedProcCount;

		glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC) getExtensionPtr( "glGetFragmentLightfvSGIX" );
		if ( glGetFragmentLightfvSGIX != 0 )	++localInitializedProcCount;

		glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC) getExtensionPtr( "glGetFragmentLightivSGIX" );
		if ( glGetFragmentLightivSGIX != 0 )	++localInitializedProcCount;

		glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC) getExtensionPtr( "glGetFragmentMaterialfvSGIX" );
		if ( glGetFragmentMaterialfvSGIX != 0 )	++localInitializedProcCount;

		glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC) getExtensionPtr( "glGetFragmentMaterialivSGIX" );
		if ( glGetFragmentMaterialivSGIX != 0 )	++localInitializedProcCount;

		glLightEnviSGIX = (PFNGLLIGHTENVISGIXPROC) getExtensionPtr( "glLightEnviSGIX" );
		if ( glLightEnviSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_fragment_lighting )

	if ( isGL_SGIX_fragment_lighting )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_fragment_lighting                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_fragment_lighting                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_fragment_lighting") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_fragment_lighting                         : not detected." );
	}


	isGL_SGIX_framezoom = isExtensionSupported("GL_SGIX_framezoom");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_framezoom ) // || isSEDEnable()
	{
		glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC) getExtensionPtr( "glFrameZoomSGIX" );
		if ( glFrameZoomSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_framezoom )

	if ( isGL_SGIX_framezoom )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_framezoom                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_framezoom                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_framezoom") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_framezoom                                 : not detected." );
	}


	isGL_SGIX_igloo_interface = isExtensionSupported("GL_SGIX_igloo_interface");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_igloo_interface ) // || isSEDEnable()
	{
		glIglooInterfaceSGIX = (PFNGLIGLOOINTERFACESGIXPROC) getExtensionPtr( "glIglooInterfaceSGIX" );
		if ( glIglooInterfaceSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_igloo_interface )

	if ( isGL_SGIX_igloo_interface )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_igloo_interface                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_igloo_interface                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_igloo_interface") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_igloo_interface                           : not detected." );
	}


	isGL_SGIX_impact_pixel_texture = isExtensionSupported("GL_SGIX_impact_pixel_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_impact_pixel_texture )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_impact_pixel_texture                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_impact_pixel_texture                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_impact_pixel_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_impact_pixel_texture                      : not detected." );
	}


	isGL_SGIX_instruments = isExtensionSupported("GL_SGIX_instruments");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_instruments ) // || isSEDEnable()
	{
		glGetInstrumentsSGIX = (PFNGLGETINSTRUMENTSSGIXPROC) getExtensionPtr( "glGetInstrumentsSGIX" );
		if ( glGetInstrumentsSGIX != 0 )	++localInitializedProcCount;

		glInstrumentsBufferSGIX = (PFNGLINSTRUMENTSBUFFERSGIXPROC) getExtensionPtr( "glInstrumentsBufferSGIX" );
		if ( glInstrumentsBufferSGIX != 0 )	++localInitializedProcCount;

		glPollInstrumentsSGIX = (PFNGLPOLLINSTRUMENTSSGIXPROC) getExtensionPtr( "glPollInstrumentsSGIX" );
		if ( glPollInstrumentsSGIX != 0 )	++localInitializedProcCount;

		glReadInstrumentsSGIX = (PFNGLREADINSTRUMENTSSGIXPROC) getExtensionPtr( "glReadInstrumentsSGIX" );
		if ( glReadInstrumentsSGIX != 0 )	++localInitializedProcCount;

		glStartInstrumentsSGIX = (PFNGLSTARTINSTRUMENTSSGIXPROC) getExtensionPtr( "glStartInstrumentsSGIX" );
		if ( glStartInstrumentsSGIX != 0 )	++localInitializedProcCount;

		glStopInstrumentsSGIX = (PFNGLSTOPINSTRUMENTSSGIXPROC) getExtensionPtr( "glStopInstrumentsSGIX" );
		if ( glStopInstrumentsSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_instruments )

	if ( isGL_SGIX_instruments )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_instruments                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_instruments                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_instruments") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_instruments                               : not detected." );
	}


	isGL_SGIX_interlace = isExtensionSupported("GL_SGIX_interlace");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_interlace )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_interlace                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_interlace                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_interlace") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_interlace                                 : not detected." );
	}


	isGL_SGIX_ir_instrument1 = isExtensionSupported("GL_SGIX_ir_instrument1");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_ir_instrument1 )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_ir_instrument1                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_ir_instrument1                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_ir_instrument1") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_ir_instrument1                            : not detected." );
	}


	isGL_SGIX_list_priority = isExtensionSupported("GL_SGIX_list_priority");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_list_priority ) // || isSEDEnable()
	{
		glGetListParameterfvSGIX = (PFNGLGETLISTPARAMETERFVSGIXPROC) getExtensionPtr( "glGetListParameterfvSGIX" );
		if ( glGetListParameterfvSGIX != 0 )	++localInitializedProcCount;

		glGetListParameterivSGIX = (PFNGLGETLISTPARAMETERIVSGIXPROC) getExtensionPtr( "glGetListParameterivSGIX" );
		if ( glGetListParameterivSGIX != 0 )	++localInitializedProcCount;

		glListParameterfSGIX = (PFNGLLISTPARAMETERFSGIXPROC) getExtensionPtr( "glListParameterfSGIX" );
		if ( glListParameterfSGIX != 0 )	++localInitializedProcCount;

		glListParameterfvSGIX = (PFNGLLISTPARAMETERFVSGIXPROC) getExtensionPtr( "glListParameterfvSGIX" );
		if ( glListParameterfvSGIX != 0 )	++localInitializedProcCount;

		glListParameteriSGIX = (PFNGLLISTPARAMETERISGIXPROC) getExtensionPtr( "glListParameteriSGIX" );
		if ( glListParameteriSGIX != 0 )	++localInitializedProcCount;

		glListParameterivSGIX = (PFNGLLISTPARAMETERIVSGIXPROC) getExtensionPtr( "glListParameterivSGIX" );
		if ( glListParameterivSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_list_priority )

	if ( isGL_SGIX_list_priority )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_list_priority                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_list_priority                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_list_priority") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_list_priority                             : not detected." );
	}


	isGL_SGIX_pixel_texture = isExtensionSupported("GL_SGIX_pixel_texture");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_pixel_texture ) // || isSEDEnable()
	{
		glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC) getExtensionPtr( "glPixelTexGenSGIX" );
		if ( glPixelTexGenSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_pixel_texture )

	if ( isGL_SGIX_pixel_texture )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_pixel_texture                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_pixel_texture                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_pixel_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_pixel_texture                             : not detected." );
	}


	isGL_SGIX_pixel_tiles = isExtensionSupported("GL_SGIX_pixel_tiles");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_pixel_tiles )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_pixel_tiles                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_pixel_tiles                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_pixel_tiles") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_pixel_tiles                               : not detected." );
	}


	isGL_SGIX_polynomial_ffd = isExtensionSupported("GL_SGIX_polynomial_ffd");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_polynomial_ffd ) // || isSEDEnable()
	{
		glDeformSGIX = (PFNGLDEFORMSGIXPROC) getExtensionPtr( "glDeformSGIX" );
		if ( glDeformSGIX != 0 )	++localInitializedProcCount;

		glDeformationMap3dSGIX = (PFNGLDEFORMATIONMAP3DSGIXPROC) getExtensionPtr( "glDeformationMap3dSGIX" );
		if ( glDeformationMap3dSGIX != 0 )	++localInitializedProcCount;

		glDeformationMap3fSGIX = (PFNGLDEFORMATIONMAP3FSGIXPROC) getExtensionPtr( "glDeformationMap3fSGIX" );
		if ( glDeformationMap3fSGIX != 0 )	++localInitializedProcCount;

		glLoadIdentityDeformationMapSGIX = (PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) getExtensionPtr( "glLoadIdentityDeformationMapSGIX" );
		if ( glLoadIdentityDeformationMapSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_polynomial_ffd )

	if ( isGL_SGIX_polynomial_ffd )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_polynomial_ffd                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_polynomial_ffd                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_polynomial_ffd") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_polynomial_ffd                            : not detected." );
	}


	isGL_SGIX_reference_plane = isExtensionSupported("GL_SGIX_reference_plane");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_reference_plane ) // || isSEDEnable()
	{
		glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC) getExtensionPtr( "glReferencePlaneSGIX" );
		if ( glReferencePlaneSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_reference_plane )

	if ( isGL_SGIX_reference_plane )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_reference_plane                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_reference_plane                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_reference_plane") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_reference_plane                           : not detected." );
	}


	isGL_SGIX_resample = isExtensionSupported("GL_SGIX_resample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_resample )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_resample                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_resample                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_resample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_resample                                  : not detected." );
	}


	isGL_SGIX_scalebias_hint = isExtensionSupported("GL_SGIX_scalebias_hint");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_scalebias_hint )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_scalebias_hint                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_scalebias_hint                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_scalebias_hint") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_scalebias_hint                            : not detected." );
	}


	isGL_SGIX_shadow = isExtensionSupported("GL_SGIX_shadow");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_shadow )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_shadow                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_shadow                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_shadow") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_shadow                                    : not detected." );
	}


	isGL_SGIX_shadow_ambient = isExtensionSupported("GL_SGIX_shadow_ambient");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_shadow_ambient )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_shadow_ambient                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_shadow_ambient                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_shadow_ambient") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_shadow_ambient                            : not detected." );
	}


	isGL_SGIX_sprite = isExtensionSupported("GL_SGIX_sprite");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_sprite ) // || isSEDEnable()
	{
		glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC) getExtensionPtr( "glSpriteParameterfSGIX" );
		if ( glSpriteParameterfSGIX != 0 )	++localInitializedProcCount;

		glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC) getExtensionPtr( "glSpriteParameterfvSGIX" );
		if ( glSpriteParameterfvSGIX != 0 )	++localInitializedProcCount;

		glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC) getExtensionPtr( "glSpriteParameteriSGIX" );
		if ( glSpriteParameteriSGIX != 0 )	++localInitializedProcCount;

		glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC) getExtensionPtr( "glSpriteParameterivSGIX" );
		if ( glSpriteParameterivSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_sprite )

	if ( isGL_SGIX_sprite )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_sprite                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_sprite                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_sprite") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_sprite                                    : not detected." );
	}


	isGL_SGIX_subsample = isExtensionSupported("GL_SGIX_subsample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_subsample )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_subsample                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_subsample                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_subsample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_subsample                                 : not detected." );
	}


	isGL_SGIX_tag_sample_buffer = isExtensionSupported("GL_SGIX_tag_sample_buffer");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_tag_sample_buffer ) // || isSEDEnable()
	{
		glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC) getExtensionPtr( "glTagSampleBufferSGIX" );
		if ( glTagSampleBufferSGIX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SGIX_tag_sample_buffer )

	if ( isGL_SGIX_tag_sample_buffer )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_tag_sample_buffer                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_tag_sample_buffer                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_tag_sample_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_tag_sample_buffer                         : not detected." );
	}


	isGL_SGIX_texture_add_env = isExtensionSupported("GL_SGIX_texture_add_env");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_texture_add_env )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_texture_add_env                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_texture_add_env                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_texture_add_env") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_texture_add_env                           : not detected." );
	}


	isGL_SGIX_texture_coordinate_clamp = isExtensionSupported("GL_SGIX_texture_coordinate_clamp");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_texture_coordinate_clamp )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_texture_coordinate_clamp                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_texture_coordinate_clamp                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_texture_coordinate_clamp") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_texture_coordinate_clamp                  : not detected." );
	}


	isGL_SGIX_texture_lod_bias = isExtensionSupported("GL_SGIX_texture_lod_bias");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_texture_lod_bias )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_texture_lod_bias                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_texture_lod_bias                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_texture_lod_bias") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_texture_lod_bias                          : not detected." );
	}


	isGL_SGIX_texture_multi_buffer = isExtensionSupported("GL_SGIX_texture_multi_buffer");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_texture_multi_buffer )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_texture_multi_buffer                      : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_texture_multi_buffer                      : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_texture_multi_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_texture_multi_buffer                      : not detected." );
	}


	isGL_SGIX_texture_scale_bias = isExtensionSupported("GL_SGIX_texture_scale_bias");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_texture_scale_bias )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_texture_scale_bias                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_texture_scale_bias                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_texture_scale_bias") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_texture_scale_bias                        : not detected." );
	}


	isGL_SGIX_texture_select = isExtensionSupported("GL_SGIX_texture_select");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_texture_select )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_texture_select                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_texture_select                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_texture_select") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_texture_select                            : not detected." );
	}


	isGL_SGIX_vertex_preclip = isExtensionSupported("GL_SGIX_vertex_preclip");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_vertex_preclip )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_vertex_preclip                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_vertex_preclip                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_vertex_preclip") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_vertex_preclip                            : not detected." );
	}


	isGL_SGIX_ycrcb = isExtensionSupported("GL_SGIX_ycrcb");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_ycrcb )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_ycrcb                                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_ycrcb                                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_ycrcb") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_ycrcb                                     : not detected." );
	}


	isGL_SGIX_ycrcb_subsample = isExtensionSupported("GL_SGIX_ycrcb_subsample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_ycrcb_subsample )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_ycrcb_subsample                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_ycrcb_subsample                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_ycrcb_subsample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_ycrcb_subsample                           : not detected." );
	}


	isGL_SGIX_ycrcba = isExtensionSupported("GL_SGIX_ycrcba");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SGIX_ycrcba )
	{
		std::stringstream strStream;
		strStream << "GL_SGIX_ycrcba                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SGIX_ycrcba                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SGIX_ycrcba") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SGIX_ycrcba                                    : not detected." );
	}


} // initializeGL_SGIX_ycrcba()


void OpenGLExtensionsGen::initializeGL_SUN()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_SUN_convolution_border_modes = isExtensionSupported("GL_SUN_convolution_border_modes");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SUN_convolution_border_modes )
	{
		std::stringstream strStream;
		strStream << "GL_SUN_convolution_border_modes                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUN_convolution_border_modes                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUN_convolution_border_modes") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUN_convolution_border_modes                   : not detected." );
	}


	isGL_SUN_global_alpha = isExtensionSupported("GL_SUN_global_alpha");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isGL_SUN_global_alpha ) // || isSEDEnable()
	{
		glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC) getExtensionPtr( "glGlobalAlphaFactorbSUN" );
		if ( glGlobalAlphaFactorbSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC) getExtensionPtr( "glGlobalAlphaFactordSUN" );
		if ( glGlobalAlphaFactordSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC) getExtensionPtr( "glGlobalAlphaFactorfSUN" );
		if ( glGlobalAlphaFactorfSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC) getExtensionPtr( "glGlobalAlphaFactoriSUN" );
		if ( glGlobalAlphaFactoriSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC) getExtensionPtr( "glGlobalAlphaFactorsSUN" );
		if ( glGlobalAlphaFactorsSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC) getExtensionPtr( "glGlobalAlphaFactorubSUN" );
		if ( glGlobalAlphaFactorubSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC) getExtensionPtr( "glGlobalAlphaFactoruiSUN" );
		if ( glGlobalAlphaFactoruiSUN != 0 )	++localInitializedProcCount;

		glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC) getExtensionPtr( "glGlobalAlphaFactorusSUN" );
		if ( glGlobalAlphaFactorusSUN != 0 )	++localInitializedProcCount;

	} // if ( isGL_SUN_global_alpha )

	if ( isGL_SUN_global_alpha )
	{
		std::stringstream strStream;
		strStream << "GL_SUN_global_alpha                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUN_global_alpha                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUN_global_alpha") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUN_global_alpha                               : not detected." );
	}


	isGL_SUN_mesh_array = isExtensionSupported("GL_SUN_mesh_array");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SUN_mesh_array ) // || isSEDEnable()
	{
		glDrawMeshArraysSUN = (PFNGLDRAWMESHARRAYSSUNPROC) getExtensionPtr( "glDrawMeshArraysSUN" );
		if ( glDrawMeshArraysSUN != 0 )	++localInitializedProcCount;

	} // if ( isGL_SUN_mesh_array )

	if ( isGL_SUN_mesh_array )
	{
		std::stringstream strStream;
		strStream << "GL_SUN_mesh_array                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUN_mesh_array                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUN_mesh_array") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUN_mesh_array                                 : not detected." );
	}


	isGL_SUN_slice_accum = isExtensionSupported("GL_SUN_slice_accum");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_SUN_slice_accum )
	{
		std::stringstream strStream;
		strStream << "GL_SUN_slice_accum                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUN_slice_accum                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUN_slice_accum") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUN_slice_accum                                : not detected." );
	}


	isGL_SUN_triangle_list = isExtensionSupported("GL_SUN_triangle_list");

	localSupportedProcCount		= 7;
	localInitializedProcCount	= 0;

	if ( isGL_SUN_triangle_list ) // || isSEDEnable()
	{
		glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC) getExtensionPtr( "glReplacementCodePointerSUN" );
		if ( glReplacementCodePointerSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC) getExtensionPtr( "glReplacementCodeubSUN" );
		if ( glReplacementCodeubSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC) getExtensionPtr( "glReplacementCodeubvSUN" );
		if ( glReplacementCodeubvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC) getExtensionPtr( "glReplacementCodeuiSUN" );
		if ( glReplacementCodeuiSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC) getExtensionPtr( "glReplacementCodeuivSUN" );
		if ( glReplacementCodeuivSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC) getExtensionPtr( "glReplacementCodeusSUN" );
		if ( glReplacementCodeusSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC) getExtensionPtr( "glReplacementCodeusvSUN" );
		if ( glReplacementCodeusvSUN != 0 )	++localInitializedProcCount;

	} // if ( isGL_SUN_triangle_list )

	if ( isGL_SUN_triangle_list )
	{
		std::stringstream strStream;
		strStream << "GL_SUN_triangle_list                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUN_triangle_list                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUN_triangle_list") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUN_triangle_list                              : not detected." );
	}


	isGL_SUN_vertex = isExtensionSupported("GL_SUN_vertex");

	localSupportedProcCount		= 40;
	localInitializedProcCount	= 0;

	if ( isGL_SUN_vertex ) // || isSEDEnable()
	{
		glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC) getExtensionPtr( "glColor3fVertex3fSUN" );
		if ( glColor3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC) getExtensionPtr( "glColor3fVertex3fvSUN" );
		if ( glColor3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glColor4fNormal3fVertex3fSUN" );
		if ( glColor4fNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glColor4fNormal3fVertex3fvSUN" );
		if ( glColor4fNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC) getExtensionPtr( "glColor4ubVertex2fSUN" );
		if ( glColor4ubVertex2fSUN != 0 )	++localInitializedProcCount;

		glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC) getExtensionPtr( "glColor4ubVertex2fvSUN" );
		if ( glColor4ubVertex2fvSUN != 0 )	++localInitializedProcCount;

		glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC) getExtensionPtr( "glColor4ubVertex3fSUN" );
		if ( glColor4ubVertex3fSUN != 0 )	++localInitializedProcCount;

		glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC) getExtensionPtr( "glColor4ubVertex3fvSUN" );
		if ( glColor4ubVertex3fvSUN != 0 )	++localInitializedProcCount;

		glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glNormal3fVertex3fSUN" );
		if ( glNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glNormal3fVertex3fvSUN" );
		if ( glNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiColor3fVertex3fSUN" );
		if ( glReplacementCodeuiColor3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiColor3fVertex3fvSUN" );
		if ( glReplacementCodeuiColor3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiColor4fNormal3fVertex3fSUN" );
		if ( glReplacementCodeuiColor4fNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiColor4fNormal3fVertex3fvSUN" );
		if ( glReplacementCodeuiColor4fNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiColor4ubVertex3fSUN" );
		if ( glReplacementCodeuiColor4ubVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiColor4ubVertex3fvSUN" );
		if ( glReplacementCodeuiColor4ubVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiNormal3fVertex3fSUN" );
		if ( glReplacementCodeuiNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiNormal3fVertex3fvSUN" );
		if ( glReplacementCodeuiNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN" );
		if ( glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN" );
		if ( glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN" );
		if ( glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN" );
		if ( glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiTexCoord2fVertex3fSUN" );
		if ( glReplacementCodeuiTexCoord2fVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiTexCoord2fVertex3fvSUN" );
		if ( glReplacementCodeuiTexCoord2fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) getExtensionPtr( "glReplacementCodeuiVertex3fSUN" );
		if ( glReplacementCodeuiVertex3fSUN != 0 )	++localInitializedProcCount;

		glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) getExtensionPtr( "glReplacementCodeuiVertex3fvSUN" );
		if ( glReplacementCodeuiVertex3fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) getExtensionPtr( "glTexCoord2fColor3fVertex3fSUN" );
		if ( glTexCoord2fColor3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) getExtensionPtr( "glTexCoord2fColor3fVertex3fvSUN" );
		if ( glTexCoord2fColor3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glTexCoord2fColor4fNormal3fVertex3fSUN" );
		if ( glTexCoord2fColor4fNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glTexCoord2fColor4fNormal3fVertex3fvSUN" );
		if ( glTexCoord2fColor4fNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) getExtensionPtr( "glTexCoord2fColor4ubVertex3fSUN" );
		if ( glTexCoord2fColor4ubVertex3fSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) getExtensionPtr( "glTexCoord2fColor4ubVertex3fvSUN" );
		if ( glTexCoord2fColor4ubVertex3fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) getExtensionPtr( "glTexCoord2fNormal3fVertex3fSUN" );
		if ( glTexCoord2fNormal3fVertex3fSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) getExtensionPtr( "glTexCoord2fNormal3fVertex3fvSUN" );
		if ( glTexCoord2fNormal3fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC) getExtensionPtr( "glTexCoord2fVertex3fSUN" );
		if ( glTexCoord2fVertex3fSUN != 0 )	++localInitializedProcCount;

		glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC) getExtensionPtr( "glTexCoord2fVertex3fvSUN" );
		if ( glTexCoord2fVertex3fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) getExtensionPtr( "glTexCoord4fColor4fNormal3fVertex4fSUN" );
		if ( glTexCoord4fColor4fNormal3fVertex4fSUN != 0 )	++localInitializedProcCount;

		glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) getExtensionPtr( "glTexCoord4fColor4fNormal3fVertex4fvSUN" );
		if ( glTexCoord4fColor4fNormal3fVertex4fvSUN != 0 )	++localInitializedProcCount;

		glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC) getExtensionPtr( "glTexCoord4fVertex4fSUN" );
		if ( glTexCoord4fVertex4fSUN != 0 )	++localInitializedProcCount;

		glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC) getExtensionPtr( "glTexCoord4fVertex4fvSUN" );
		if ( glTexCoord4fVertex4fvSUN != 0 )	++localInitializedProcCount;

	} // if ( isGL_SUN_vertex )

	if ( isGL_SUN_vertex )
	{
		std::stringstream strStream;
		strStream << "GL_SUN_vertex                                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUN_vertex                                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUN_vertex") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUN_vertex                                     : not detected." );
	}


} // initializeGL_SUN_vertex()


void OpenGLExtensionsGen::initializeGL_SUNX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_SUNX_constant_data = isExtensionSupported("GL_SUNX_constant_data");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_SUNX_constant_data ) // || isSEDEnable()
	{
		glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC) getExtensionPtr( "glFinishTextureSUNX" );
		if ( glFinishTextureSUNX != 0 )	++localInitializedProcCount;

	} // if ( isGL_SUNX_constant_data )

	if ( isGL_SUNX_constant_data )
	{
		std::stringstream strStream;
		strStream << "GL_SUNX_constant_data                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_SUNX_constant_data                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_SUNX_constant_data") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_SUNX_constant_data                             : not detected." );
	}


} // initializeGL_SUNX_constant_data()


void OpenGLExtensionsGen::initializeGL_VERSION()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_VERSION_1_2 = true;

	localSupportedProcCount		= 38;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_1_2 ) // || isSEDEnable()
	{
		glBlendColor = (PFNGLBLENDCOLORPROC) getExtensionPtr( "glBlendColor" );
		if ( glBlendColor != 0 )	++localInitializedProcCount;

		glBlendEquation = (PFNGLBLENDEQUATIONPROC) getExtensionPtr( "glBlendEquation" );
		if ( glBlendEquation != 0 )	++localInitializedProcCount;

		glColorSubTable = (PFNGLCOLORSUBTABLEPROC) getExtensionPtr( "glColorSubTable" );
		if ( glColorSubTable != 0 )	++localInitializedProcCount;

		glColorTable = (PFNGLCOLORTABLEPROC) getExtensionPtr( "glColorTable" );
		if ( glColorTable != 0 )	++localInitializedProcCount;

		glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC) getExtensionPtr( "glColorTableParameterfv" );
		if ( glColorTableParameterfv != 0 )	++localInitializedProcCount;

		glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC) getExtensionPtr( "glColorTableParameteriv" );
		if ( glColorTableParameteriv != 0 )	++localInitializedProcCount;

		glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC) getExtensionPtr( "glConvolutionFilter1D" );
		if ( glConvolutionFilter1D != 0 )	++localInitializedProcCount;

		glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC) getExtensionPtr( "glConvolutionFilter2D" );
		if ( glConvolutionFilter2D != 0 )	++localInitializedProcCount;

		glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC) getExtensionPtr( "glConvolutionParameterf" );
		if ( glConvolutionParameterf != 0 )	++localInitializedProcCount;

		glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC) getExtensionPtr( "glConvolutionParameterfv" );
		if ( glConvolutionParameterfv != 0 )	++localInitializedProcCount;

		glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC) getExtensionPtr( "glConvolutionParameteri" );
		if ( glConvolutionParameteri != 0 )	++localInitializedProcCount;

		glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC) getExtensionPtr( "glConvolutionParameteriv" );
		if ( glConvolutionParameteriv != 0 )	++localInitializedProcCount;

		glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC) getExtensionPtr( "glCopyColorSubTable" );
		if ( glCopyColorSubTable != 0 )	++localInitializedProcCount;

		glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC) getExtensionPtr( "glCopyColorTable" );
		if ( glCopyColorTable != 0 )	++localInitializedProcCount;

		glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC) getExtensionPtr( "glCopyConvolutionFilter1D" );
		if ( glCopyConvolutionFilter1D != 0 )	++localInitializedProcCount;

		glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC) getExtensionPtr( "glCopyConvolutionFilter2D" );
		if ( glCopyConvolutionFilter2D != 0 )	++localInitializedProcCount;

		glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC) getExtensionPtr( "glCopyTexSubImage3D" );
		if ( glCopyTexSubImage3D != 0 )	++localInitializedProcCount;

		glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC) getExtensionPtr( "glDrawRangeElements" );
		if ( glDrawRangeElements != 0 )	++localInitializedProcCount;

		glGetColorTable = (PFNGLGETCOLORTABLEPROC) getExtensionPtr( "glGetColorTable" );
		if ( glGetColorTable != 0 )	++localInitializedProcCount;

		glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC) getExtensionPtr( "glGetColorTableParameterfv" );
		if ( glGetColorTableParameterfv != 0 )	++localInitializedProcCount;

		glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC) getExtensionPtr( "glGetColorTableParameteriv" );
		if ( glGetColorTableParameteriv != 0 )	++localInitializedProcCount;

		glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC) getExtensionPtr( "glGetConvolutionFilter" );
		if ( glGetConvolutionFilter != 0 )	++localInitializedProcCount;

		glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC) getExtensionPtr( "glGetConvolutionParameterfv" );
		if ( glGetConvolutionParameterfv != 0 )	++localInitializedProcCount;

		glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC) getExtensionPtr( "glGetConvolutionParameteriv" );
		if ( glGetConvolutionParameteriv != 0 )	++localInitializedProcCount;

		glGetHistogram = (PFNGLGETHISTOGRAMPROC) getExtensionPtr( "glGetHistogram" );
		if ( glGetHistogram != 0 )	++localInitializedProcCount;

		glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC) getExtensionPtr( "glGetHistogramParameterfv" );
		if ( glGetHistogramParameterfv != 0 )	++localInitializedProcCount;

		glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC) getExtensionPtr( "glGetHistogramParameteriv" );
		if ( glGetHistogramParameteriv != 0 )	++localInitializedProcCount;

		glGetMinmax = (PFNGLGETMINMAXPROC) getExtensionPtr( "glGetMinmax" );
		if ( glGetMinmax != 0 )	++localInitializedProcCount;

		glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC) getExtensionPtr( "glGetMinmaxParameterfv" );
		if ( glGetMinmaxParameterfv != 0 )	++localInitializedProcCount;

		glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC) getExtensionPtr( "glGetMinmaxParameteriv" );
		if ( glGetMinmaxParameteriv != 0 )	++localInitializedProcCount;

		glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC) getExtensionPtr( "glGetSeparableFilter" );
		if ( glGetSeparableFilter != 0 )	++localInitializedProcCount;

		glHistogram = (PFNGLHISTOGRAMPROC) getExtensionPtr( "glHistogram" );
		if ( glHistogram != 0 )	++localInitializedProcCount;

		glMinmax = (PFNGLMINMAXPROC) getExtensionPtr( "glMinmax" );
		if ( glMinmax != 0 )	++localInitializedProcCount;

		glResetHistogram = (PFNGLRESETHISTOGRAMPROC) getExtensionPtr( "glResetHistogram" );
		if ( glResetHistogram != 0 )	++localInitializedProcCount;

		glResetMinmax = (PFNGLRESETMINMAXPROC) getExtensionPtr( "glResetMinmax" );
		if ( glResetMinmax != 0 )	++localInitializedProcCount;

		glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC) getExtensionPtr( "glSeparableFilter2D" );
		if ( glSeparableFilter2D != 0 )	++localInitializedProcCount;

		glTexImage3D = (PFNGLTEXIMAGE3DPROC) getExtensionPtr( "glTexImage3D" );
		if ( glTexImage3D != 0 )	++localInitializedProcCount;

		glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC) getExtensionPtr( "glTexSubImage3D" );
		if ( glTexSubImage3D != 0 )	++localInitializedProcCount;

		isGL_VERSION_1_2 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_1_2 )

	if ( isGL_VERSION_1_2 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_1_2                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_1_2                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_1_2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_1_2                                    : not detected." );
	}


	isGL_VERSION_1_3 = true;

	localSupportedProcCount		= 46;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_1_3 ) // || isSEDEnable()
	{
		glActiveTexture = (PFNGLACTIVETEXTUREPROC) getExtensionPtr( "glActiveTexture" );
		if ( glActiveTexture != 0 )	++localInitializedProcCount;

		glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC) getExtensionPtr( "glClientActiveTexture" );
		if ( glClientActiveTexture != 0 )	++localInitializedProcCount;

		glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC) getExtensionPtr( "glCompressedTexImage1D" );
		if ( glCompressedTexImage1D != 0 )	++localInitializedProcCount;

		glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) getExtensionPtr( "glCompressedTexImage2D" );
		if ( glCompressedTexImage2D != 0 )	++localInitializedProcCount;

		glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC) getExtensionPtr( "glCompressedTexImage3D" );
		if ( glCompressedTexImage3D != 0 )	++localInitializedProcCount;

		glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) getExtensionPtr( "glCompressedTexSubImage1D" );
		if ( glCompressedTexSubImage1D != 0 )	++localInitializedProcCount;

		glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) getExtensionPtr( "glCompressedTexSubImage2D" );
		if ( glCompressedTexSubImage2D != 0 )	++localInitializedProcCount;

		glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) getExtensionPtr( "glCompressedTexSubImage3D" );
		if ( glCompressedTexSubImage3D != 0 )	++localInitializedProcCount;

		glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC) getExtensionPtr( "glGetCompressedTexImage" );
		if ( glGetCompressedTexImage != 0 )	++localInitializedProcCount;

		glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC) getExtensionPtr( "glLoadTransposeMatrixd" );
		if ( glLoadTransposeMatrixd != 0 )	++localInitializedProcCount;

		glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC) getExtensionPtr( "glLoadTransposeMatrixf" );
		if ( glLoadTransposeMatrixf != 0 )	++localInitializedProcCount;

		glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC) getExtensionPtr( "glMultTransposeMatrixd" );
		if ( glMultTransposeMatrixd != 0 )	++localInitializedProcCount;

		glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC) getExtensionPtr( "glMultTransposeMatrixf" );
		if ( glMultTransposeMatrixf != 0 )	++localInitializedProcCount;

		glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC) getExtensionPtr( "glMultiTexCoord1d" );
		if ( glMultiTexCoord1d != 0 )	++localInitializedProcCount;

		glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC) getExtensionPtr( "glMultiTexCoord1dv" );
		if ( glMultiTexCoord1dv != 0 )	++localInitializedProcCount;

		glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC) getExtensionPtr( "glMultiTexCoord1f" );
		if ( glMultiTexCoord1f != 0 )	++localInitializedProcCount;

		glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC) getExtensionPtr( "glMultiTexCoord1fv" );
		if ( glMultiTexCoord1fv != 0 )	++localInitializedProcCount;

		glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC) getExtensionPtr( "glMultiTexCoord1i" );
		if ( glMultiTexCoord1i != 0 )	++localInitializedProcCount;

		glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC) getExtensionPtr( "glMultiTexCoord1iv" );
		if ( glMultiTexCoord1iv != 0 )	++localInitializedProcCount;

		glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC) getExtensionPtr( "glMultiTexCoord1s" );
		if ( glMultiTexCoord1s != 0 )	++localInitializedProcCount;

		glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC) getExtensionPtr( "glMultiTexCoord1sv" );
		if ( glMultiTexCoord1sv != 0 )	++localInitializedProcCount;

		glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC) getExtensionPtr( "glMultiTexCoord2d" );
		if ( glMultiTexCoord2d != 0 )	++localInitializedProcCount;

		glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC) getExtensionPtr( "glMultiTexCoord2dv" );
		if ( glMultiTexCoord2dv != 0 )	++localInitializedProcCount;

		glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC) getExtensionPtr( "glMultiTexCoord2f" );
		if ( glMultiTexCoord2f != 0 )	++localInitializedProcCount;

		glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC) getExtensionPtr( "glMultiTexCoord2fv" );
		if ( glMultiTexCoord2fv != 0 )	++localInitializedProcCount;

		glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC) getExtensionPtr( "glMultiTexCoord2i" );
		if ( glMultiTexCoord2i != 0 )	++localInitializedProcCount;

		glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC) getExtensionPtr( "glMultiTexCoord2iv" );
		if ( glMultiTexCoord2iv != 0 )	++localInitializedProcCount;

		glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC) getExtensionPtr( "glMultiTexCoord2s" );
		if ( glMultiTexCoord2s != 0 )	++localInitializedProcCount;

		glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC) getExtensionPtr( "glMultiTexCoord2sv" );
		if ( glMultiTexCoord2sv != 0 )	++localInitializedProcCount;

		glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC) getExtensionPtr( "glMultiTexCoord3d" );
		if ( glMultiTexCoord3d != 0 )	++localInitializedProcCount;

		glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC) getExtensionPtr( "glMultiTexCoord3dv" );
		if ( glMultiTexCoord3dv != 0 )	++localInitializedProcCount;

		glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC) getExtensionPtr( "glMultiTexCoord3f" );
		if ( glMultiTexCoord3f != 0 )	++localInitializedProcCount;

		glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC) getExtensionPtr( "glMultiTexCoord3fv" );
		if ( glMultiTexCoord3fv != 0 )	++localInitializedProcCount;

		glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC) getExtensionPtr( "glMultiTexCoord3i" );
		if ( glMultiTexCoord3i != 0 )	++localInitializedProcCount;

		glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC) getExtensionPtr( "glMultiTexCoord3iv" );
		if ( glMultiTexCoord3iv != 0 )	++localInitializedProcCount;

		glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC) getExtensionPtr( "glMultiTexCoord3s" );
		if ( glMultiTexCoord3s != 0 )	++localInitializedProcCount;

		glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC) getExtensionPtr( "glMultiTexCoord3sv" );
		if ( glMultiTexCoord3sv != 0 )	++localInitializedProcCount;

		glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC) getExtensionPtr( "glMultiTexCoord4d" );
		if ( glMultiTexCoord4d != 0 )	++localInitializedProcCount;

		glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC) getExtensionPtr( "glMultiTexCoord4dv" );
		if ( glMultiTexCoord4dv != 0 )	++localInitializedProcCount;

		glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC) getExtensionPtr( "glMultiTexCoord4f" );
		if ( glMultiTexCoord4f != 0 )	++localInitializedProcCount;

		glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC) getExtensionPtr( "glMultiTexCoord4fv" );
		if ( glMultiTexCoord4fv != 0 )	++localInitializedProcCount;

		glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC) getExtensionPtr( "glMultiTexCoord4i" );
		if ( glMultiTexCoord4i != 0 )	++localInitializedProcCount;

		glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC) getExtensionPtr( "glMultiTexCoord4iv" );
		if ( glMultiTexCoord4iv != 0 )	++localInitializedProcCount;

		glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC) getExtensionPtr( "glMultiTexCoord4s" );
		if ( glMultiTexCoord4s != 0 )	++localInitializedProcCount;

		glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC) getExtensionPtr( "glMultiTexCoord4sv" );
		if ( glMultiTexCoord4sv != 0 )	++localInitializedProcCount;

		glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) getExtensionPtr( "glSampleCoverage" );
		if ( glSampleCoverage != 0 )	++localInitializedProcCount;

		isGL_VERSION_1_3 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_1_3 )

	if ( isGL_VERSION_1_3 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_1_3                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_1_3                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_1_3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_1_3                                    : not detected." );
	}


	isGL_VERSION_1_4 = true;

	localSupportedProcCount		= 45;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_1_4 ) // || isSEDEnable()
	{
		glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) getExtensionPtr( "glBlendFuncSeparate" );
		if ( glBlendFuncSeparate != 0 )	++localInitializedProcCount;

		glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC) getExtensionPtr( "glFogCoordPointer" );
		if ( glFogCoordPointer != 0 )	++localInitializedProcCount;

		glFogCoordd = (PFNGLFOGCOORDDPROC) getExtensionPtr( "glFogCoordd" );
		if ( glFogCoordd != 0 )	++localInitializedProcCount;

		glFogCoorddv = (PFNGLFOGCOORDDVPROC) getExtensionPtr( "glFogCoorddv" );
		if ( glFogCoorddv != 0 )	++localInitializedProcCount;

		glFogCoordf = (PFNGLFOGCOORDFPROC) getExtensionPtr( "glFogCoordf" );
		if ( glFogCoordf != 0 )	++localInitializedProcCount;

		glFogCoordfv = (PFNGLFOGCOORDFVPROC) getExtensionPtr( "glFogCoordfv" );
		if ( glFogCoordfv != 0 )	++localInitializedProcCount;

		glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC) getExtensionPtr( "glMultiDrawArrays" );
		if ( glMultiDrawArrays != 0 )	++localInitializedProcCount;

		glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC) getExtensionPtr( "glMultiDrawElements" );
		if ( glMultiDrawElements != 0 )	++localInitializedProcCount;

		glPointParameterf = (PFNGLPOINTPARAMETERFPROC) getExtensionPtr( "glPointParameterf" );
		if ( glPointParameterf != 0 )	++localInitializedProcCount;

		glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC) getExtensionPtr( "glPointParameterfv" );
		if ( glPointParameterfv != 0 )	++localInitializedProcCount;

		glPointParameteri = (PFNGLPOINTPARAMETERIPROC) getExtensionPtr( "glPointParameteri" );
		if ( glPointParameteri != 0 )	++localInitializedProcCount;

		glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC) getExtensionPtr( "glPointParameteriv" );
		if ( glPointParameteriv != 0 )	++localInitializedProcCount;

		glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC) getExtensionPtr( "glSecondaryColor3b" );
		if ( glSecondaryColor3b != 0 )	++localInitializedProcCount;

		glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC) getExtensionPtr( "glSecondaryColor3bv" );
		if ( glSecondaryColor3bv != 0 )	++localInitializedProcCount;

		glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC) getExtensionPtr( "glSecondaryColor3d" );
		if ( glSecondaryColor3d != 0 )	++localInitializedProcCount;

		glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC) getExtensionPtr( "glSecondaryColor3dv" );
		if ( glSecondaryColor3dv != 0 )	++localInitializedProcCount;

		glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC) getExtensionPtr( "glSecondaryColor3f" );
		if ( glSecondaryColor3f != 0 )	++localInitializedProcCount;

		glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC) getExtensionPtr( "glSecondaryColor3fv" );
		if ( glSecondaryColor3fv != 0 )	++localInitializedProcCount;

		glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC) getExtensionPtr( "glSecondaryColor3i" );
		if ( glSecondaryColor3i != 0 )	++localInitializedProcCount;

		glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC) getExtensionPtr( "glSecondaryColor3iv" );
		if ( glSecondaryColor3iv != 0 )	++localInitializedProcCount;

		glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC) getExtensionPtr( "glSecondaryColor3s" );
		if ( glSecondaryColor3s != 0 )	++localInitializedProcCount;

		glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC) getExtensionPtr( "glSecondaryColor3sv" );
		if ( glSecondaryColor3sv != 0 )	++localInitializedProcCount;

		glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC) getExtensionPtr( "glSecondaryColor3ub" );
		if ( glSecondaryColor3ub != 0 )	++localInitializedProcCount;

		glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC) getExtensionPtr( "glSecondaryColor3ubv" );
		if ( glSecondaryColor3ubv != 0 )	++localInitializedProcCount;

		glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC) getExtensionPtr( "glSecondaryColor3ui" );
		if ( glSecondaryColor3ui != 0 )	++localInitializedProcCount;

		glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC) getExtensionPtr( "glSecondaryColor3uiv" );
		if ( glSecondaryColor3uiv != 0 )	++localInitializedProcCount;

		glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC) getExtensionPtr( "glSecondaryColor3us" );
		if ( glSecondaryColor3us != 0 )	++localInitializedProcCount;

		glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC) getExtensionPtr( "glSecondaryColor3usv" );
		if ( glSecondaryColor3usv != 0 )	++localInitializedProcCount;

		glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC) getExtensionPtr( "glSecondaryColorPointer" );
		if ( glSecondaryColorPointer != 0 )	++localInitializedProcCount;

		glWindowPos2d = (PFNGLWINDOWPOS2DPROC) getExtensionPtr( "glWindowPos2d" );
		if ( glWindowPos2d != 0 )	++localInitializedProcCount;

		glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC) getExtensionPtr( "glWindowPos2dv" );
		if ( glWindowPos2dv != 0 )	++localInitializedProcCount;

		glWindowPos2f = (PFNGLWINDOWPOS2FPROC) getExtensionPtr( "glWindowPos2f" );
		if ( glWindowPos2f != 0 )	++localInitializedProcCount;

		glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC) getExtensionPtr( "glWindowPos2fv" );
		if ( glWindowPos2fv != 0 )	++localInitializedProcCount;

		glWindowPos2i = (PFNGLWINDOWPOS2IPROC) getExtensionPtr( "glWindowPos2i" );
		if ( glWindowPos2i != 0 )	++localInitializedProcCount;

		glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC) getExtensionPtr( "glWindowPos2iv" );
		if ( glWindowPos2iv != 0 )	++localInitializedProcCount;

		glWindowPos2s = (PFNGLWINDOWPOS2SPROC) getExtensionPtr( "glWindowPos2s" );
		if ( glWindowPos2s != 0 )	++localInitializedProcCount;

		glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC) getExtensionPtr( "glWindowPos2sv" );
		if ( glWindowPos2sv != 0 )	++localInitializedProcCount;

		glWindowPos3d = (PFNGLWINDOWPOS3DPROC) getExtensionPtr( "glWindowPos3d" );
		if ( glWindowPos3d != 0 )	++localInitializedProcCount;

		glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC) getExtensionPtr( "glWindowPos3dv" );
		if ( glWindowPos3dv != 0 )	++localInitializedProcCount;

		glWindowPos3f = (PFNGLWINDOWPOS3FPROC) getExtensionPtr( "glWindowPos3f" );
		if ( glWindowPos3f != 0 )	++localInitializedProcCount;

		glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC) getExtensionPtr( "glWindowPos3fv" );
		if ( glWindowPos3fv != 0 )	++localInitializedProcCount;

		glWindowPos3i = (PFNGLWINDOWPOS3IPROC) getExtensionPtr( "glWindowPos3i" );
		if ( glWindowPos3i != 0 )	++localInitializedProcCount;

		glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC) getExtensionPtr( "glWindowPos3iv" );
		if ( glWindowPos3iv != 0 )	++localInitializedProcCount;

		glWindowPos3s = (PFNGLWINDOWPOS3SPROC) getExtensionPtr( "glWindowPos3s" );
		if ( glWindowPos3s != 0 )	++localInitializedProcCount;

		glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC) getExtensionPtr( "glWindowPos3sv" );
		if ( glWindowPos3sv != 0 )	++localInitializedProcCount;

		isGL_VERSION_1_4 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_1_4 )

	if ( isGL_VERSION_1_4 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_1_4                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_1_4                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_1_4") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_1_4                                    : not detected." );
	}


	isGL_VERSION_1_5 = true;

	localSupportedProcCount		= 19;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_1_5 ) // || isSEDEnable()
	{
		glBeginQuery = (PFNGLBEGINQUERYPROC) getExtensionPtr( "glBeginQuery" );
		if ( glBeginQuery != 0 )	++localInitializedProcCount;

		glBindBuffer = (PFNGLBINDBUFFERPROC) getExtensionPtr( "glBindBuffer" );
		if ( glBindBuffer != 0 )	++localInitializedProcCount;

		glBufferData = (PFNGLBUFFERDATAPROC) getExtensionPtr( "glBufferData" );
		if ( glBufferData != 0 )	++localInitializedProcCount;

		glBufferSubData = (PFNGLBUFFERSUBDATAPROC) getExtensionPtr( "glBufferSubData" );
		if ( glBufferSubData != 0 )	++localInitializedProcCount;

		glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) getExtensionPtr( "glDeleteBuffers" );
		if ( glDeleteBuffers != 0 )	++localInitializedProcCount;

		glDeleteQueries = (PFNGLDELETEQUERIESPROC) getExtensionPtr( "glDeleteQueries" );
		if ( glDeleteQueries != 0 )	++localInitializedProcCount;

		glEndQuery = (PFNGLENDQUERYPROC) getExtensionPtr( "glEndQuery" );
		if ( glEndQuery != 0 )	++localInitializedProcCount;

		glGenBuffers = (PFNGLGENBUFFERSPROC) getExtensionPtr( "glGenBuffers" );
		if ( glGenBuffers != 0 )	++localInitializedProcCount;

		glGenQueries = (PFNGLGENQUERIESPROC) getExtensionPtr( "glGenQueries" );
		if ( glGenQueries != 0 )	++localInitializedProcCount;

		glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) getExtensionPtr( "glGetBufferParameteriv" );
		if ( glGetBufferParameteriv != 0 )	++localInitializedProcCount;

		glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC) getExtensionPtr( "glGetBufferPointerv" );
		if ( glGetBufferPointerv != 0 )	++localInitializedProcCount;

		glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC) getExtensionPtr( "glGetBufferSubData" );
		if ( glGetBufferSubData != 0 )	++localInitializedProcCount;

		glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC) getExtensionPtr( "glGetQueryObjectiv" );
		if ( glGetQueryObjectiv != 0 )	++localInitializedProcCount;

		glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC) getExtensionPtr( "glGetQueryObjectuiv" );
		if ( glGetQueryObjectuiv != 0 )	++localInitializedProcCount;

		glGetQueryiv = (PFNGLGETQUERYIVPROC) getExtensionPtr( "glGetQueryiv" );
		if ( glGetQueryiv != 0 )	++localInitializedProcCount;

		glIsBuffer = (PFNGLISBUFFERPROC) getExtensionPtr( "glIsBuffer" );
		if ( glIsBuffer != 0 )	++localInitializedProcCount;

		glIsQuery = (PFNGLISQUERYPROC) getExtensionPtr( "glIsQuery" );
		if ( glIsQuery != 0 )	++localInitializedProcCount;

		glMapBuffer = (PFNGLMAPBUFFERPROC) getExtensionPtr( "glMapBuffer" );
		if ( glMapBuffer != 0 )	++localInitializedProcCount;

		glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) getExtensionPtr( "glUnmapBuffer" );
		if ( glUnmapBuffer != 0 )	++localInitializedProcCount;

		isGL_VERSION_1_5 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_1_5 )

	if ( isGL_VERSION_1_5 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_1_5                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_1_5                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_1_5") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_1_5                                    : not detected." );
	}


	isGL_VERSION_2_0 = true;

	localSupportedProcCount		= 93;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_2_0 ) // || isSEDEnable()
	{
		glAttachShader = (PFNGLATTACHSHADERPROC) getExtensionPtr( "glAttachShader" );
		if ( glAttachShader != 0 )	++localInitializedProcCount;

		glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) getExtensionPtr( "glBindAttribLocation" );
		if ( glBindAttribLocation != 0 )	++localInitializedProcCount;

		glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) getExtensionPtr( "glBlendEquationSeparate" );
		if ( glBlendEquationSeparate != 0 )	++localInitializedProcCount;

		glCompileShader = (PFNGLCOMPILESHADERPROC) getExtensionPtr( "glCompileShader" );
		if ( glCompileShader != 0 )	++localInitializedProcCount;

		glCreateProgram = (PFNGLCREATEPROGRAMPROC) getExtensionPtr( "glCreateProgram" );
		if ( glCreateProgram != 0 )	++localInitializedProcCount;

		glCreateShader = (PFNGLCREATESHADERPROC) getExtensionPtr( "glCreateShader" );
		if ( glCreateShader != 0 )	++localInitializedProcCount;

		glDeleteProgram = (PFNGLDELETEPROGRAMPROC) getExtensionPtr( "glDeleteProgram" );
		if ( glDeleteProgram != 0 )	++localInitializedProcCount;

		glDeleteShader = (PFNGLDELETESHADERPROC) getExtensionPtr( "glDeleteShader" );
		if ( glDeleteShader != 0 )	++localInitializedProcCount;

		glDetachShader = (PFNGLDETACHSHADERPROC) getExtensionPtr( "glDetachShader" );
		if ( glDetachShader != 0 )	++localInitializedProcCount;

		glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) getExtensionPtr( "glDisableVertexAttribArray" );
		if ( glDisableVertexAttribArray != 0 )	++localInitializedProcCount;

		glDrawBuffers = (PFNGLDRAWBUFFERSPROC) getExtensionPtr( "glDrawBuffers" );
		if ( glDrawBuffers != 0 )	++localInitializedProcCount;

		glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) getExtensionPtr( "glEnableVertexAttribArray" );
		if ( glEnableVertexAttribArray != 0 )	++localInitializedProcCount;

		glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) getExtensionPtr( "glGetActiveAttrib" );
		if ( glGetActiveAttrib != 0 )	++localInitializedProcCount;

		glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) getExtensionPtr( "glGetActiveUniform" );
		if ( glGetActiveUniform != 0 )	++localInitializedProcCount;

		glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) getExtensionPtr( "glGetAttachedShaders" );
		if ( glGetAttachedShaders != 0 )	++localInitializedProcCount;

		glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) getExtensionPtr( "glGetAttribLocation" );
		if ( glGetAttribLocation != 0 )	++localInitializedProcCount;

		glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) getExtensionPtr( "glGetProgramInfoLog" );
		if ( glGetProgramInfoLog != 0 )	++localInitializedProcCount;

		glGetProgramiv = (PFNGLGETPROGRAMIVPROC) getExtensionPtr( "glGetProgramiv" );
		if ( glGetProgramiv != 0 )	++localInitializedProcCount;

		glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) getExtensionPtr( "glGetShaderInfoLog" );
		if ( glGetShaderInfoLog != 0 )	++localInitializedProcCount;

		glGetShaderSource = (PFNGLGETSHADERSOURCEPROC) getExtensionPtr( "glGetShaderSource" );
		if ( glGetShaderSource != 0 )	++localInitializedProcCount;

		glGetShaderiv = (PFNGLGETSHADERIVPROC) getExtensionPtr( "glGetShaderiv" );
		if ( glGetShaderiv != 0 )	++localInitializedProcCount;

		glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) getExtensionPtr( "glGetUniformLocation" );
		if ( glGetUniformLocation != 0 )	++localInitializedProcCount;

		glGetUniformfv = (PFNGLGETUNIFORMFVPROC) getExtensionPtr( "glGetUniformfv" );
		if ( glGetUniformfv != 0 )	++localInitializedProcCount;

		glGetUniformiv = (PFNGLGETUNIFORMIVPROC) getExtensionPtr( "glGetUniformiv" );
		if ( glGetUniformiv != 0 )	++localInitializedProcCount;

		glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) getExtensionPtr( "glGetVertexAttribPointerv" );
		if ( glGetVertexAttribPointerv != 0 )	++localInitializedProcCount;

		glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC) getExtensionPtr( "glGetVertexAttribdv" );
		if ( glGetVertexAttribdv != 0 )	++localInitializedProcCount;

		glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) getExtensionPtr( "glGetVertexAttribfv" );
		if ( glGetVertexAttribfv != 0 )	++localInitializedProcCount;

		glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) getExtensionPtr( "glGetVertexAttribiv" );
		if ( glGetVertexAttribiv != 0 )	++localInitializedProcCount;

		glIsProgram = (PFNGLISPROGRAMPROC) getExtensionPtr( "glIsProgram" );
		if ( glIsProgram != 0 )	++localInitializedProcCount;

		glIsShader = (PFNGLISSHADERPROC) getExtensionPtr( "glIsShader" );
		if ( glIsShader != 0 )	++localInitializedProcCount;

		glLinkProgram = (PFNGLLINKPROGRAMPROC) getExtensionPtr( "glLinkProgram" );
		if ( glLinkProgram != 0 )	++localInitializedProcCount;

		glShaderSource = (PFNGLSHADERSOURCEPROC) getExtensionPtr( "glShaderSource" );
		if ( glShaderSource != 0 )	++localInitializedProcCount;

		glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) getExtensionPtr( "glStencilFuncSeparate" );
		if ( glStencilFuncSeparate != 0 )	++localInitializedProcCount;

		glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) getExtensionPtr( "glStencilMaskSeparate" );
		if ( glStencilMaskSeparate != 0 )	++localInitializedProcCount;

		glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) getExtensionPtr( "glStencilOpSeparate" );
		if ( glStencilOpSeparate != 0 )	++localInitializedProcCount;

		glUniform1f = (PFNGLUNIFORM1FPROC) getExtensionPtr( "glUniform1f" );
		if ( glUniform1f != 0 )	++localInitializedProcCount;

		glUniform1fv = (PFNGLUNIFORM1FVPROC) getExtensionPtr( "glUniform1fv" );
		if ( glUniform1fv != 0 )	++localInitializedProcCount;

		glUniform1i = (PFNGLUNIFORM1IPROC) getExtensionPtr( "glUniform1i" );
		if ( glUniform1i != 0 )	++localInitializedProcCount;

		glUniform1iv = (PFNGLUNIFORM1IVPROC) getExtensionPtr( "glUniform1iv" );
		if ( glUniform1iv != 0 )	++localInitializedProcCount;

		glUniform2f = (PFNGLUNIFORM2FPROC) getExtensionPtr( "glUniform2f" );
		if ( glUniform2f != 0 )	++localInitializedProcCount;

		glUniform2fv = (PFNGLUNIFORM2FVPROC) getExtensionPtr( "glUniform2fv" );
		if ( glUniform2fv != 0 )	++localInitializedProcCount;

		glUniform2i = (PFNGLUNIFORM2IPROC) getExtensionPtr( "glUniform2i" );
		if ( glUniform2i != 0 )	++localInitializedProcCount;

		glUniform2iv = (PFNGLUNIFORM2IVPROC) getExtensionPtr( "glUniform2iv" );
		if ( glUniform2iv != 0 )	++localInitializedProcCount;

		glUniform3f = (PFNGLUNIFORM3FPROC) getExtensionPtr( "glUniform3f" );
		if ( glUniform3f != 0 )	++localInitializedProcCount;

		glUniform3fv = (PFNGLUNIFORM3FVPROC) getExtensionPtr( "glUniform3fv" );
		if ( glUniform3fv != 0 )	++localInitializedProcCount;

		glUniform3i = (PFNGLUNIFORM3IPROC) getExtensionPtr( "glUniform3i" );
		if ( glUniform3i != 0 )	++localInitializedProcCount;

		glUniform3iv = (PFNGLUNIFORM3IVPROC) getExtensionPtr( "glUniform3iv" );
		if ( glUniform3iv != 0 )	++localInitializedProcCount;

		glUniform4f = (PFNGLUNIFORM4FPROC) getExtensionPtr( "glUniform4f" );
		if ( glUniform4f != 0 )	++localInitializedProcCount;

		glUniform4fv = (PFNGLUNIFORM4FVPROC) getExtensionPtr( "glUniform4fv" );
		if ( glUniform4fv != 0 )	++localInitializedProcCount;

		glUniform4i = (PFNGLUNIFORM4IPROC) getExtensionPtr( "glUniform4i" );
		if ( glUniform4i != 0 )	++localInitializedProcCount;

		glUniform4iv = (PFNGLUNIFORM4IVPROC) getExtensionPtr( "glUniform4iv" );
		if ( glUniform4iv != 0 )	++localInitializedProcCount;

		glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) getExtensionPtr( "glUniformMatrix2fv" );
		if ( glUniformMatrix2fv != 0 )	++localInitializedProcCount;

		glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) getExtensionPtr( "glUniformMatrix3fv" );
		if ( glUniformMatrix3fv != 0 )	++localInitializedProcCount;

		glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) getExtensionPtr( "glUniformMatrix4fv" );
		if ( glUniformMatrix4fv != 0 )	++localInitializedProcCount;

		glUseProgram = (PFNGLUSEPROGRAMPROC) getExtensionPtr( "glUseProgram" );
		if ( glUseProgram != 0 )	++localInitializedProcCount;

		glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) getExtensionPtr( "glValidateProgram" );
		if ( glValidateProgram != 0 )	++localInitializedProcCount;

		glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC) getExtensionPtr( "glVertexAttrib1d" );
		if ( glVertexAttrib1d != 0 )	++localInitializedProcCount;

		glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC) getExtensionPtr( "glVertexAttrib1dv" );
		if ( glVertexAttrib1dv != 0 )	++localInitializedProcCount;

		glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) getExtensionPtr( "glVertexAttrib1f" );
		if ( glVertexAttrib1f != 0 )	++localInitializedProcCount;

		glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) getExtensionPtr( "glVertexAttrib1fv" );
		if ( glVertexAttrib1fv != 0 )	++localInitializedProcCount;

		glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC) getExtensionPtr( "glVertexAttrib1s" );
		if ( glVertexAttrib1s != 0 )	++localInitializedProcCount;

		glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC) getExtensionPtr( "glVertexAttrib1sv" );
		if ( glVertexAttrib1sv != 0 )	++localInitializedProcCount;

		glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC) getExtensionPtr( "glVertexAttrib2d" );
		if ( glVertexAttrib2d != 0 )	++localInitializedProcCount;

		glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC) getExtensionPtr( "glVertexAttrib2dv" );
		if ( glVertexAttrib2dv != 0 )	++localInitializedProcCount;

		glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) getExtensionPtr( "glVertexAttrib2f" );
		if ( glVertexAttrib2f != 0 )	++localInitializedProcCount;

		glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) getExtensionPtr( "glVertexAttrib2fv" );
		if ( glVertexAttrib2fv != 0 )	++localInitializedProcCount;

		glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC) getExtensionPtr( "glVertexAttrib2s" );
		if ( glVertexAttrib2s != 0 )	++localInitializedProcCount;

		glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC) getExtensionPtr( "glVertexAttrib2sv" );
		if ( glVertexAttrib2sv != 0 )	++localInitializedProcCount;

		glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC) getExtensionPtr( "glVertexAttrib3d" );
		if ( glVertexAttrib3d != 0 )	++localInitializedProcCount;

		glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC) getExtensionPtr( "glVertexAttrib3dv" );
		if ( glVertexAttrib3dv != 0 )	++localInitializedProcCount;

		glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) getExtensionPtr( "glVertexAttrib3f" );
		if ( glVertexAttrib3f != 0 )	++localInitializedProcCount;

		glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) getExtensionPtr( "glVertexAttrib3fv" );
		if ( glVertexAttrib3fv != 0 )	++localInitializedProcCount;

		glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC) getExtensionPtr( "glVertexAttrib3s" );
		if ( glVertexAttrib3s != 0 )	++localInitializedProcCount;

		glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC) getExtensionPtr( "glVertexAttrib3sv" );
		if ( glVertexAttrib3sv != 0 )	++localInitializedProcCount;

		glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC) getExtensionPtr( "glVertexAttrib4Nbv" );
		if ( glVertexAttrib4Nbv != 0 )	++localInitializedProcCount;

		glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC) getExtensionPtr( "glVertexAttrib4Niv" );
		if ( glVertexAttrib4Niv != 0 )	++localInitializedProcCount;

		glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC) getExtensionPtr( "glVertexAttrib4Nsv" );
		if ( glVertexAttrib4Nsv != 0 )	++localInitializedProcCount;

		glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC) getExtensionPtr( "glVertexAttrib4Nub" );
		if ( glVertexAttrib4Nub != 0 )	++localInitializedProcCount;

		glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC) getExtensionPtr( "glVertexAttrib4Nubv" );
		if ( glVertexAttrib4Nubv != 0 )	++localInitializedProcCount;

		glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC) getExtensionPtr( "glVertexAttrib4Nuiv" );
		if ( glVertexAttrib4Nuiv != 0 )	++localInitializedProcCount;

		glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC) getExtensionPtr( "glVertexAttrib4Nusv" );
		if ( glVertexAttrib4Nusv != 0 )	++localInitializedProcCount;

		glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC) getExtensionPtr( "glVertexAttrib4bv" );
		if ( glVertexAttrib4bv != 0 )	++localInitializedProcCount;

		glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC) getExtensionPtr( "glVertexAttrib4d" );
		if ( glVertexAttrib4d != 0 )	++localInitializedProcCount;

		glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC) getExtensionPtr( "glVertexAttrib4dv" );
		if ( glVertexAttrib4dv != 0 )	++localInitializedProcCount;

		glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) getExtensionPtr( "glVertexAttrib4f" );
		if ( glVertexAttrib4f != 0 )	++localInitializedProcCount;

		glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) getExtensionPtr( "glVertexAttrib4fv" );
		if ( glVertexAttrib4fv != 0 )	++localInitializedProcCount;

		glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC) getExtensionPtr( "glVertexAttrib4iv" );
		if ( glVertexAttrib4iv != 0 )	++localInitializedProcCount;

		glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC) getExtensionPtr( "glVertexAttrib4s" );
		if ( glVertexAttrib4s != 0 )	++localInitializedProcCount;

		glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC) getExtensionPtr( "glVertexAttrib4sv" );
		if ( glVertexAttrib4sv != 0 )	++localInitializedProcCount;

		glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC) getExtensionPtr( "glVertexAttrib4ubv" );
		if ( glVertexAttrib4ubv != 0 )	++localInitializedProcCount;

		glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC) getExtensionPtr( "glVertexAttrib4uiv" );
		if ( glVertexAttrib4uiv != 0 )	++localInitializedProcCount;

		glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC) getExtensionPtr( "glVertexAttrib4usv" );
		if ( glVertexAttrib4usv != 0 )	++localInitializedProcCount;

		glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) getExtensionPtr( "glVertexAttribPointer" );
		if ( glVertexAttribPointer != 0 )	++localInitializedProcCount;

		isGL_VERSION_2_0 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_2_0 )

	if ( isGL_VERSION_2_0 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_2_0                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_2_0                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_2_0") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_2_0                                    : not detected." );
	}


	isGL_VERSION_2_1 = true;

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_2_1 ) // || isSEDEnable()
	{
		glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC) getExtensionPtr( "glUniformMatrix2x3fv" );
		if ( glUniformMatrix2x3fv != 0 )	++localInitializedProcCount;

		glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC) getExtensionPtr( "glUniformMatrix2x4fv" );
		if ( glUniformMatrix2x4fv != 0 )	++localInitializedProcCount;

		glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC) getExtensionPtr( "glUniformMatrix3x2fv" );
		if ( glUniformMatrix3x2fv != 0 )	++localInitializedProcCount;

		glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC) getExtensionPtr( "glUniformMatrix3x4fv" );
		if ( glUniformMatrix3x4fv != 0 )	++localInitializedProcCount;

		glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC) getExtensionPtr( "glUniformMatrix4x2fv" );
		if ( glUniformMatrix4x2fv != 0 )	++localInitializedProcCount;

		glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC) getExtensionPtr( "glUniformMatrix4x3fv" );
		if ( glUniformMatrix4x3fv != 0 )	++localInitializedProcCount;

		isGL_VERSION_2_1 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_2_1 )

	if ( isGL_VERSION_2_1 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_2_1                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_2_1                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_2_1") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_2_1                                    : not detected." );
	}


	isGL_VERSION_3_0 = true;

	localSupportedProcCount		= 58;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_3_0 ) // || isSEDEnable()
	{
		glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC) getExtensionPtr( "glBeginConditionalRender" );
		if ( glBeginConditionalRender != 0 )	++localInitializedProcCount;

		glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC) getExtensionPtr( "glBeginTransformFeedback" );
		if ( glBeginTransformFeedback != 0 )	++localInitializedProcCount;

		glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) getExtensionPtr( "glBindBufferBase" );
		if ( glBindBufferBase != 0 )	++localInitializedProcCount;

		glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) getExtensionPtr( "glBindBufferRange" );
		if ( glBindBufferRange != 0 )	++localInitializedProcCount;

		glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC) getExtensionPtr( "glBindFragDataLocation" );
		if ( glBindFragDataLocation != 0 )	++localInitializedProcCount;

		glClampColor = (PFNGLCLAMPCOLORPROC) getExtensionPtr( "glClampColor" );
		if ( glClampColor != 0 )	++localInitializedProcCount;

		glClearBufferfi = (PFNGLCLEARBUFFERFIPROC) getExtensionPtr( "glClearBufferfi" );
		if ( glClearBufferfi != 0 )	++localInitializedProcCount;

		glClearBufferfv = (PFNGLCLEARBUFFERFVPROC) getExtensionPtr( "glClearBufferfv" );
		if ( glClearBufferfv != 0 )	++localInitializedProcCount;

		glClearBufferiv = (PFNGLCLEARBUFFERIVPROC) getExtensionPtr( "glClearBufferiv" );
		if ( glClearBufferiv != 0 )	++localInitializedProcCount;

		glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC) getExtensionPtr( "glClearBufferuiv" );
		if ( glClearBufferuiv != 0 )	++localInitializedProcCount;

		glColorMaski = (PFNGLCOLORMASKIPROC) getExtensionPtr( "glColorMaski" );
		if ( glColorMaski != 0 )	++localInitializedProcCount;

		glDisablei = (PFNGLDISABLEIPROC) getExtensionPtr( "glDisablei" );
		if ( glDisablei != 0 )	++localInitializedProcCount;

		glEnablei = (PFNGLENABLEIPROC) getExtensionPtr( "glEnablei" );
		if ( glEnablei != 0 )	++localInitializedProcCount;

		glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC) getExtensionPtr( "glEndConditionalRender" );
		if ( glEndConditionalRender != 0 )	++localInitializedProcCount;

		glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC) getExtensionPtr( "glEndTransformFeedback" );
		if ( glEndTransformFeedback != 0 )	++localInitializedProcCount;

		glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC) getExtensionPtr( "glGetBooleani_v" );
		if ( glGetBooleani_v != 0 )	++localInitializedProcCount;

		glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC) getExtensionPtr( "glGetFragDataLocation" );
		if ( glGetFragDataLocation != 0 )	++localInitializedProcCount;

		glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC) getExtensionPtr( "glGetIntegeri_v" );
		if ( glGetIntegeri_v != 0 )	++localInitializedProcCount;

		glGetStringi = (PFNGLGETSTRINGIPROC) getExtensionPtr( "glGetStringi" );
		if ( glGetStringi != 0 )	++localInitializedProcCount;

		glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC) getExtensionPtr( "glGetTexParameterIiv" );
		if ( glGetTexParameterIiv != 0 )	++localInitializedProcCount;

		glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC) getExtensionPtr( "glGetTexParameterIuiv" );
		if ( glGetTexParameterIuiv != 0 )	++localInitializedProcCount;

		glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) getExtensionPtr( "glGetTransformFeedbackVarying" );
		if ( glGetTransformFeedbackVarying != 0 )	++localInitializedProcCount;

		glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC) getExtensionPtr( "glGetUniformuiv" );
		if ( glGetUniformuiv != 0 )	++localInitializedProcCount;

		glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC) getExtensionPtr( "glGetVertexAttribIiv" );
		if ( glGetVertexAttribIiv != 0 )	++localInitializedProcCount;

		glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC) getExtensionPtr( "glGetVertexAttribIuiv" );
		if ( glGetVertexAttribIuiv != 0 )	++localInitializedProcCount;

		glIsEnabledi = (PFNGLISENABLEDIPROC) getExtensionPtr( "glIsEnabledi" );
		if ( glIsEnabledi != 0 )	++localInitializedProcCount;

		glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC) getExtensionPtr( "glTexParameterIiv" );
		if ( glTexParameterIiv != 0 )	++localInitializedProcCount;

		glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC) getExtensionPtr( "glTexParameterIuiv" );
		if ( glTexParameterIuiv != 0 )	++localInitializedProcCount;

		glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC) getExtensionPtr( "glTransformFeedbackVaryings" );
		if ( glTransformFeedbackVaryings != 0 )	++localInitializedProcCount;

		glUniform1ui = (PFNGLUNIFORM1UIPROC) getExtensionPtr( "glUniform1ui" );
		if ( glUniform1ui != 0 )	++localInitializedProcCount;

		glUniform1uiv = (PFNGLUNIFORM1UIVPROC) getExtensionPtr( "glUniform1uiv" );
		if ( glUniform1uiv != 0 )	++localInitializedProcCount;

		glUniform2ui = (PFNGLUNIFORM2UIPROC) getExtensionPtr( "glUniform2ui" );
		if ( glUniform2ui != 0 )	++localInitializedProcCount;

		glUniform2uiv = (PFNGLUNIFORM2UIVPROC) getExtensionPtr( "glUniform2uiv" );
		if ( glUniform2uiv != 0 )	++localInitializedProcCount;

		glUniform3ui = (PFNGLUNIFORM3UIPROC) getExtensionPtr( "glUniform3ui" );
		if ( glUniform3ui != 0 )	++localInitializedProcCount;

		glUniform3uiv = (PFNGLUNIFORM3UIVPROC) getExtensionPtr( "glUniform3uiv" );
		if ( glUniform3uiv != 0 )	++localInitializedProcCount;

		glUniform4ui = (PFNGLUNIFORM4UIPROC) getExtensionPtr( "glUniform4ui" );
		if ( glUniform4ui != 0 )	++localInitializedProcCount;

		glUniform4uiv = (PFNGLUNIFORM4UIVPROC) getExtensionPtr( "glUniform4uiv" );
		if ( glUniform4uiv != 0 )	++localInitializedProcCount;

		glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC) getExtensionPtr( "glVertexAttribI1i" );
		if ( glVertexAttribI1i != 0 )	++localInitializedProcCount;

		glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC) getExtensionPtr( "glVertexAttribI1iv" );
		if ( glVertexAttribI1iv != 0 )	++localInitializedProcCount;

		glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC) getExtensionPtr( "glVertexAttribI1ui" );
		if ( glVertexAttribI1ui != 0 )	++localInitializedProcCount;

		glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC) getExtensionPtr( "glVertexAttribI1uiv" );
		if ( glVertexAttribI1uiv != 0 )	++localInitializedProcCount;

		glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC) getExtensionPtr( "glVertexAttribI2i" );
		if ( glVertexAttribI2i != 0 )	++localInitializedProcCount;

		glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC) getExtensionPtr( "glVertexAttribI2iv" );
		if ( glVertexAttribI2iv != 0 )	++localInitializedProcCount;

		glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC) getExtensionPtr( "glVertexAttribI2ui" );
		if ( glVertexAttribI2ui != 0 )	++localInitializedProcCount;

		glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC) getExtensionPtr( "glVertexAttribI2uiv" );
		if ( glVertexAttribI2uiv != 0 )	++localInitializedProcCount;

		glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC) getExtensionPtr( "glVertexAttribI3i" );
		if ( glVertexAttribI3i != 0 )	++localInitializedProcCount;

		glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC) getExtensionPtr( "glVertexAttribI3iv" );
		if ( glVertexAttribI3iv != 0 )	++localInitializedProcCount;

		glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC) getExtensionPtr( "glVertexAttribI3ui" );
		if ( glVertexAttribI3ui != 0 )	++localInitializedProcCount;

		glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC) getExtensionPtr( "glVertexAttribI3uiv" );
		if ( glVertexAttribI3uiv != 0 )	++localInitializedProcCount;

		glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC) getExtensionPtr( "glVertexAttribI4bv" );
		if ( glVertexAttribI4bv != 0 )	++localInitializedProcCount;

		glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC) getExtensionPtr( "glVertexAttribI4i" );
		if ( glVertexAttribI4i != 0 )	++localInitializedProcCount;

		glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC) getExtensionPtr( "glVertexAttribI4iv" );
		if ( glVertexAttribI4iv != 0 )	++localInitializedProcCount;

		glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC) getExtensionPtr( "glVertexAttribI4sv" );
		if ( glVertexAttribI4sv != 0 )	++localInitializedProcCount;

		glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC) getExtensionPtr( "glVertexAttribI4ubv" );
		if ( glVertexAttribI4ubv != 0 )	++localInitializedProcCount;

		glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC) getExtensionPtr( "glVertexAttribI4ui" );
		if ( glVertexAttribI4ui != 0 )	++localInitializedProcCount;

		glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC) getExtensionPtr( "glVertexAttribI4uiv" );
		if ( glVertexAttribI4uiv != 0 )	++localInitializedProcCount;

		glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC) getExtensionPtr( "glVertexAttribI4usv" );
		if ( glVertexAttribI4usv != 0 )	++localInitializedProcCount;

		glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC) getExtensionPtr( "glVertexAttribIPointer" );
		if ( glVertexAttribIPointer != 0 )	++localInitializedProcCount;

		isGL_VERSION_3_0 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_3_0 )

	if ( isGL_VERSION_3_0 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_3_0                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_3_0                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_3_0") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_3_0                                    : not detected." );
	}


	isGL_VERSION_3_1 = true;

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_3_1 ) // || isSEDEnable()
	{
		glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC) getExtensionPtr( "glDrawArraysInstanced" );
		if ( glDrawArraysInstanced != 0 )	++localInitializedProcCount;

		glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC) getExtensionPtr( "glDrawElementsInstanced" );
		if ( glDrawElementsInstanced != 0 )	++localInitializedProcCount;

		glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC) getExtensionPtr( "glPrimitiveRestartIndex" );
		if ( glPrimitiveRestartIndex != 0 )	++localInitializedProcCount;

		glTexBuffer = (PFNGLTEXBUFFERPROC) getExtensionPtr( "glTexBuffer" );
		if ( glTexBuffer != 0 )	++localInitializedProcCount;

		isGL_VERSION_3_1 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_3_1 )

	if ( isGL_VERSION_3_1 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_3_1                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_3_1                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_3_1") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_3_1                                    : not detected." );
	}


	isGL_VERSION_3_2 = true;

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_3_2 ) // || isSEDEnable()
	{
		glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC) getExtensionPtr( "glFramebufferTexture" );
		if ( glFramebufferTexture != 0 )	++localInitializedProcCount;

		glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC) getExtensionPtr( "glGetBufferParameteri64v" );
		if ( glGetBufferParameteri64v != 0 )	++localInitializedProcCount;

		glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC) getExtensionPtr( "glGetInteger64i_v" );
		if ( glGetInteger64i_v != 0 )	++localInitializedProcCount;

		isGL_VERSION_3_2 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_3_2 )

	if ( isGL_VERSION_3_2 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_3_2                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_3_2                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_3_2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_3_2                                    : not detected." );
	}


	isGL_VERSION_3_3 = true;

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_3_3 ) // || isSEDEnable()
	{
		glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC) getExtensionPtr( "glVertexAttribDivisor" );
		if ( glVertexAttribDivisor != 0 )	++localInitializedProcCount;

		isGL_VERSION_3_3 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_3_3 )

	if ( isGL_VERSION_3_3 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_3_3                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_3_3                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_3_3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_3_3                                    : not detected." );
	}


	isGL_VERSION_4_0 = true;

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_4_0 ) // || isSEDEnable()
	{
		glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC) getExtensionPtr( "glBlendEquationSeparatei" );
		if ( glBlendEquationSeparatei != 0 )	++localInitializedProcCount;

		glBlendEquationi = (PFNGLBLENDEQUATIONIPROC) getExtensionPtr( "glBlendEquationi" );
		if ( glBlendEquationi != 0 )	++localInitializedProcCount;

		glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC) getExtensionPtr( "glBlendFuncSeparatei" );
		if ( glBlendFuncSeparatei != 0 )	++localInitializedProcCount;

		glBlendFunci = (PFNGLBLENDFUNCIPROC) getExtensionPtr( "glBlendFunci" );
		if ( glBlendFunci != 0 )	++localInitializedProcCount;

		glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC) getExtensionPtr( "glMinSampleShading" );
		if ( glMinSampleShading != 0 )	++localInitializedProcCount;

		isGL_VERSION_4_0 = (localInitializedProcCount == localSupportedProcCount);
	} // if ( isGL_VERSION_4_0 )

	if ( isGL_VERSION_4_0 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_4_0                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_4_0                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_4_0") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_4_0                                    : not detected." );
	}


	isGL_VERSION_4_1 = true;

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_4_1 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_4_1                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_4_1                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_4_1") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_4_1                                    : not detected." );
	}


	isGL_VERSION_4_2 = true;

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_4_2 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_4_2                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_4_2                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_4_2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_4_2                                    : not detected." );
	}


	isGL_VERSION_4_3 = true;

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_VERSION_4_3 )
	{
		std::stringstream strStream;
		strStream << "GL_VERSION_4_3                                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_VERSION_4_3                                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_VERSION_4_3") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_VERSION_4_3                                    : not detected." );
	}


} // initializeGL_VERSION_4_3()


void OpenGLExtensionsGen::initializeGL_WIN()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

	isGL_WIN_phong_shading = isExtensionSupported("GL_WIN_phong_shading");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_WIN_phong_shading )
	{
		std::stringstream strStream;
		strStream << "GL_WIN_phong_shading                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_WIN_phong_shading                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_WIN_phong_shading") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_WIN_phong_shading                              : not detected." );
	}


	isGL_WIN_specular_fog = isExtensionSupported("GL_WIN_specular_fog");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isGL_WIN_specular_fog )
	{
		std::stringstream strStream;
		strStream << "GL_WIN_specular_fog                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "GL_WIN_specular_fog                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("GL_WIN_specular_fog") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "GL_WIN_specular_fog                               : not detected." );
	}


} // initializeGL_WIN_specular_fog()


void OpenGLExtensionsGen::initializeWGL_3DFX()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_3DFX_multisample ******

	isWGL_3DFX_multisample = isWExtensionSupported("WGL_3DFX_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_3DFX_multisample )
	{
		std::stringstream strStream;
		strStream << "WGL_3DFX_multisample                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_3DFX_multisample                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_3DFX_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_3DFX_multisample                              : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_3DFX_multisample()


void OpenGLExtensionsGen::initializeWGL_3DL()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_3DL_stereo_control ******

	isWGL_3DL_stereo_control = isWExtensionSupported("WGL_3DL_stereo_control");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isWGL_3DL_stereo_control ) // || isSEDEnable()
	{
		wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC) getExtensionPtr( "wglSetStereoEmitterState3DL" );
		if ( wglSetStereoEmitterState3DL != 0 )	++localInitializedProcCount;

	} // if ( isWGL_3DL_stereo_control )

	if ( isWGL_3DL_stereo_control )
	{
		std::stringstream strStream;
		strStream << "WGL_3DL_stereo_control                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_3DL_stereo_control                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_3DL_stereo_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_3DL_stereo_control                            : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_3DL_stereo_control()


void OpenGLExtensionsGen::initializeWGL_AMD()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_AMD_gpu_association ******

	isWGL_AMD_gpu_association = isWExtensionSupported("WGL_AMD_gpu_association");

	localSupportedProcCount		= 9;
	localInitializedProcCount	= 0;

	if ( isWGL_AMD_gpu_association ) // || isSEDEnable()
	{
		wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) getExtensionPtr( "wglBlitContextFramebufferAMD" );
		if ( wglBlitContextFramebufferAMD != 0 )	++localInitializedProcCount;

		wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) getExtensionPtr( "wglCreateAssociatedContextAMD" );
		if ( wglCreateAssociatedContextAMD != 0 )	++localInitializedProcCount;

		wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) getExtensionPtr( "wglCreateAssociatedContextAttribsAMD" );
		if ( wglCreateAssociatedContextAttribsAMD != 0 )	++localInitializedProcCount;

		wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) getExtensionPtr( "wglDeleteAssociatedContextAMD" );
		if ( wglDeleteAssociatedContextAMD != 0 )	++localInitializedProcCount;

		wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC) getExtensionPtr( "wglGetContextGPUIDAMD" );
		if ( wglGetContextGPUIDAMD != 0 )	++localInitializedProcCount;

		wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) getExtensionPtr( "wglGetCurrentAssociatedContextAMD" );
		if ( wglGetCurrentAssociatedContextAMD != 0 )	++localInitializedProcCount;

		wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC) getExtensionPtr( "wglGetGPUIDsAMD" );
		if ( wglGetGPUIDsAMD != 0 )	++localInitializedProcCount;

		wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC) getExtensionPtr( "wglGetGPUInfoAMD" );
		if ( wglGetGPUInfoAMD != 0 )	++localInitializedProcCount;

		wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) getExtensionPtr( "wglMakeAssociatedContextCurrentAMD" );
		if ( wglMakeAssociatedContextCurrentAMD != 0 )	++localInitializedProcCount;

	} // if ( isWGL_AMD_gpu_association )

	if ( isWGL_AMD_gpu_association )
	{
		std::stringstream strStream;
		strStream << "WGL_AMD_gpu_association                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_AMD_gpu_association                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_AMD_gpu_association") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_AMD_gpu_association                           : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_AMD_gpu_association()


void OpenGLExtensionsGen::initializeWGL_ARB()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_ARB_buffer_region ******

	isWGL_ARB_buffer_region = isWExtensionSupported("WGL_ARB_buffer_region");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_buffer_region ) // || isSEDEnable()
	{
		wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC) getExtensionPtr( "wglCreateBufferRegionARB" );
		if ( wglCreateBufferRegionARB != 0 )	++localInitializedProcCount;

		wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC) getExtensionPtr( "wglDeleteBufferRegionARB" );
		if ( wglDeleteBufferRegionARB != 0 )	++localInitializedProcCount;

		wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC) getExtensionPtr( "wglRestoreBufferRegionARB" );
		if ( wglRestoreBufferRegionARB != 0 )	++localInitializedProcCount;

		wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC) getExtensionPtr( "wglSaveBufferRegionARB" );
		if ( wglSaveBufferRegionARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_buffer_region )

	if ( isWGL_ARB_buffer_region )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_buffer_region                             : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_buffer_region                             : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_buffer_region") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_buffer_region                             : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_create_context ******

	isWGL_ARB_create_context = isWExtensionSupported("WGL_ARB_create_context");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_create_context ) // || isSEDEnable()
	{
		wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) getExtensionPtr( "wglCreateContextAttribsARB" );
		if ( wglCreateContextAttribsARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_create_context )

	if ( isWGL_ARB_create_context )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_create_context                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_create_context                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_create_context") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_create_context                            : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_create_context_profile ******

	isWGL_ARB_create_context_profile = isWExtensionSupported("WGL_ARB_create_context_profile");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_create_context_profile )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_create_context_profile                    : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_create_context_profile                    : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_create_context_profile") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_create_context_profile                    : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_create_context_robustness ******

	isWGL_ARB_create_context_robustness = isWExtensionSupported("WGL_ARB_create_context_robustness");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_create_context_robustness )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_create_context_robustness                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_create_context_robustness                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_create_context_robustness") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_create_context_robustness                 : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_extensions_string ******

	isWGL_ARB_extensions_string = isWExtensionSupported("WGL_ARB_extensions_string");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_extensions_string ) // || isSEDEnable()
	{
		wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) getExtensionPtr( "wglGetExtensionsStringARB" );
		if ( wglGetExtensionsStringARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_extensions_string )

	if ( isWGL_ARB_extensions_string )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_extensions_string                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_extensions_string                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_extensions_string") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_extensions_string                         : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_framebuffer_sRGB ******

	isWGL_ARB_framebuffer_sRGB = isWExtensionSupported("WGL_ARB_framebuffer_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_framebuffer_sRGB )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_framebuffer_sRGB                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_framebuffer_sRGB                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_framebuffer_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_framebuffer_sRGB                          : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_make_current_read ******

	isWGL_ARB_make_current_read = isWExtensionSupported("WGL_ARB_make_current_read");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_make_current_read ) // || isSEDEnable()
	{
		wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC) getExtensionPtr( "wglGetCurrentReadDCARB" );
		if ( wglGetCurrentReadDCARB != 0 )	++localInitializedProcCount;

		wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC) getExtensionPtr( "wglMakeContextCurrentARB" );
		if ( wglMakeContextCurrentARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_make_current_read )

	if ( isWGL_ARB_make_current_read )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_make_current_read                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_make_current_read                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_make_current_read") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_make_current_read                         : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_multisample ******

	isWGL_ARB_multisample = isWExtensionSupported("WGL_ARB_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_multisample )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_multisample                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_multisample                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_multisample                               : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_pbuffer ******

	isWGL_ARB_pbuffer = isWExtensionSupported("WGL_ARB_pbuffer");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_pbuffer ) // || isSEDEnable()
	{
		wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) getExtensionPtr( "wglCreatePbufferARB" );
		if ( wglCreatePbufferARB != 0 )	++localInitializedProcCount;

		wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC) getExtensionPtr( "wglDestroyPbufferARB" );
		if ( wglDestroyPbufferARB != 0 )	++localInitializedProcCount;

		wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) getExtensionPtr( "wglGetPbufferDCARB" );
		if ( wglGetPbufferDCARB != 0 )	++localInitializedProcCount;

		wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC) getExtensionPtr( "wglQueryPbufferARB" );
		if ( wglQueryPbufferARB != 0 )	++localInitializedProcCount;

		wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC) getExtensionPtr( "wglReleasePbufferDCARB" );
		if ( wglReleasePbufferDCARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_pbuffer )

	if ( isWGL_ARB_pbuffer )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_pbuffer                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_pbuffer                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_pbuffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_pbuffer                                   : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_pixel_format ******

	isWGL_ARB_pixel_format = isWExtensionSupported("WGL_ARB_pixel_format");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_pixel_format ) // || isSEDEnable()
	{
		wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) getExtensionPtr( "wglChoosePixelFormatARB" );
		if ( wglChoosePixelFormatARB != 0 )	++localInitializedProcCount;

		wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC) getExtensionPtr( "wglGetPixelFormatAttribfvARB" );
		if ( wglGetPixelFormatAttribfvARB != 0 )	++localInitializedProcCount;

		wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC) getExtensionPtr( "wglGetPixelFormatAttribivARB" );
		if ( wglGetPixelFormatAttribivARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_pixel_format )

	if ( isWGL_ARB_pixel_format )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_pixel_format                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_pixel_format                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_pixel_format") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_pixel_format                              : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_pixel_format_float ******

	isWGL_ARB_pixel_format_float = isWExtensionSupported("WGL_ARB_pixel_format_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_pixel_format_float )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_pixel_format_float                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_pixel_format_float                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_pixel_format_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_pixel_format_float                        : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_ARB_render_texture ******

	isWGL_ARB_render_texture = isWExtensionSupported("WGL_ARB_render_texture");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isWGL_ARB_render_texture ) // || isSEDEnable()
	{
		wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC) getExtensionPtr( "wglBindTexImageARB" );
		if ( wglBindTexImageARB != 0 )	++localInitializedProcCount;

		wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC) getExtensionPtr( "wglReleaseTexImageARB" );
		if ( wglReleaseTexImageARB != 0 )	++localInitializedProcCount;

		wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC) getExtensionPtr( "wglSetPbufferAttribARB" );
		if ( wglSetPbufferAttribARB != 0 )	++localInitializedProcCount;

	} // if ( isWGL_ARB_render_texture )

	if ( isWGL_ARB_render_texture )
	{
		std::stringstream strStream;
		strStream << "WGL_ARB_render_texture                            : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ARB_render_texture                            : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ARB_render_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ARB_render_texture                            : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_ARB_render_texture()


void OpenGLExtensionsGen::initializeWGL_ATI()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_ATI_pixel_format_float ******

	isWGL_ATI_pixel_format_float = isWExtensionSupported("WGL_ATI_pixel_format_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_ATI_pixel_format_float )
	{
		std::stringstream strStream;
		strStream << "WGL_ATI_pixel_format_float                        : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_ATI_pixel_format_float                        : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_ATI_pixel_format_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_ATI_pixel_format_float                        : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_ATI_pixel_format_float()


void OpenGLExtensionsGen::initializeWGL_EXT()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_EXT_create_context_es2_profile ******

	isWGL_EXT_create_context_es2_profile = isWExtensionSupported("WGL_EXT_create_context_es2_profile");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_create_context_es2_profile )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_create_context_es2_profile                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_create_context_es2_profile                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_create_context_es2_profile") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_create_context_es2_profile                : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_depth_float ******

	isWGL_EXT_depth_float = isWExtensionSupported("WGL_EXT_depth_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_depth_float )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_depth_float                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_depth_float                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_depth_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_depth_float                               : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_display_color_table ******

	isWGL_EXT_display_color_table = isWExtensionSupported("WGL_EXT_display_color_table");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_display_color_table ) // || isSEDEnable()
	{
		wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) getExtensionPtr( "wglBindDisplayColorTableEXT" );
		if ( wglBindDisplayColorTableEXT != 0 )	++localInitializedProcCount;

		wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) getExtensionPtr( "wglCreateDisplayColorTableEXT" );
		if ( wglCreateDisplayColorTableEXT != 0 )	++localInitializedProcCount;

		wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) getExtensionPtr( "wglDestroyDisplayColorTableEXT" );
		if ( wglDestroyDisplayColorTableEXT != 0 )	++localInitializedProcCount;

		wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) getExtensionPtr( "wglLoadDisplayColorTableEXT" );
		if ( wglLoadDisplayColorTableEXT != 0 )	++localInitializedProcCount;

	} // if ( isWGL_EXT_display_color_table )

	if ( isWGL_EXT_display_color_table )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_display_color_table                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_display_color_table                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_display_color_table") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_display_color_table                       : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_extensions_string ******

	isWGL_EXT_extensions_string = isWExtensionSupported("WGL_EXT_extensions_string");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_extensions_string ) // || isSEDEnable()
	{
		wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) getExtensionPtr( "wglGetExtensionsStringEXT" );
		if ( wglGetExtensionsStringEXT != 0 )	++localInitializedProcCount;

	} // if ( isWGL_EXT_extensions_string )

	if ( isWGL_EXT_extensions_string )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_extensions_string                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_extensions_string                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_extensions_string") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_extensions_string                         : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_framebuffer_sRGB ******

	isWGL_EXT_framebuffer_sRGB = isWExtensionSupported("WGL_EXT_framebuffer_sRGB");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_framebuffer_sRGB )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_framebuffer_sRGB                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_framebuffer_sRGB                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_framebuffer_sRGB") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_framebuffer_sRGB                          : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_make_current_read ******

	isWGL_EXT_make_current_read = isWExtensionSupported("WGL_EXT_make_current_read");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_make_current_read ) // || isSEDEnable()
	{
		wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC) getExtensionPtr( "wglGetCurrentReadDCEXT" );
		if ( wglGetCurrentReadDCEXT != 0 )	++localInitializedProcCount;

		wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC) getExtensionPtr( "wglMakeContextCurrentEXT" );
		if ( wglMakeContextCurrentEXT != 0 )	++localInitializedProcCount;

	} // if ( isWGL_EXT_make_current_read )

	if ( isWGL_EXT_make_current_read )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_make_current_read                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_make_current_read                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_make_current_read") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_make_current_read                         : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_multisample ******

	isWGL_EXT_multisample = isWExtensionSupported("WGL_EXT_multisample");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_multisample )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_multisample                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_multisample                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_multisample") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_multisample                               : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_pbuffer ******

	isWGL_EXT_pbuffer = isWExtensionSupported("WGL_EXT_pbuffer");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_pbuffer ) // || isSEDEnable()
	{
		wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC) getExtensionPtr( "wglCreatePbufferEXT" );
		if ( wglCreatePbufferEXT != 0 )	++localInitializedProcCount;

		wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC) getExtensionPtr( "wglDestroyPbufferEXT" );
		if ( wglDestroyPbufferEXT != 0 )	++localInitializedProcCount;

		wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC) getExtensionPtr( "wglGetPbufferDCEXT" );
		if ( wglGetPbufferDCEXT != 0 )	++localInitializedProcCount;

		wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC) getExtensionPtr( "wglQueryPbufferEXT" );
		if ( wglQueryPbufferEXT != 0 )	++localInitializedProcCount;

		wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC) getExtensionPtr( "wglReleasePbufferDCEXT" );
		if ( wglReleasePbufferDCEXT != 0 )	++localInitializedProcCount;

	} // if ( isWGL_EXT_pbuffer )

	if ( isWGL_EXT_pbuffer )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_pbuffer                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_pbuffer                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_pbuffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_pbuffer                                   : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_pixel_format ******

	isWGL_EXT_pixel_format = isWExtensionSupported("WGL_EXT_pixel_format");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_pixel_format ) // || isSEDEnable()
	{
		wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC) getExtensionPtr( "wglChoosePixelFormatEXT" );
		if ( wglChoosePixelFormatEXT != 0 )	++localInitializedProcCount;

		wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) getExtensionPtr( "wglGetPixelFormatAttribfvEXT" );
		if ( wglGetPixelFormatAttribfvEXT != 0 )	++localInitializedProcCount;

		wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) getExtensionPtr( "wglGetPixelFormatAttribivEXT" );
		if ( wglGetPixelFormatAttribivEXT != 0 )	++localInitializedProcCount;

	} // if ( isWGL_EXT_pixel_format )

	if ( isWGL_EXT_pixel_format )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_pixel_format                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_pixel_format                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_pixel_format") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_pixel_format                              : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_pixel_format_packed_float ******

	isWGL_EXT_pixel_format_packed_float = isWExtensionSupported("WGL_EXT_pixel_format_packed_float");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_pixel_format_packed_float )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_pixel_format_packed_float                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_pixel_format_packed_float                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_pixel_format_packed_float") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_pixel_format_packed_float                 : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_swap_control ******

	isWGL_EXT_swap_control = isWExtensionSupported("WGL_EXT_swap_control");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_swap_control ) // || isSEDEnable()
	{
		wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC) getExtensionPtr( "wglGetSwapIntervalEXT" );
		if ( wglGetSwapIntervalEXT != 0 )	++localInitializedProcCount;

		wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) getExtensionPtr( "wglSwapIntervalEXT" );
		if ( wglSwapIntervalEXT != 0 )	++localInitializedProcCount;

	} // if ( isWGL_EXT_swap_control )

	if ( isWGL_EXT_swap_control )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_swap_control                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_swap_control                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_swap_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_swap_control                              : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_EXT_swap_control_tear ******

	isWGL_EXT_swap_control_tear = isWExtensionSupported("WGL_EXT_swap_control_tear");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_EXT_swap_control_tear )
	{
		std::stringstream strStream;
		strStream << "WGL_EXT_swap_control_tear                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_EXT_swap_control_tear                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_EXT_swap_control_tear") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_EXT_swap_control_tear                         : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_EXT_swap_control_tear()


void OpenGLExtensionsGen::initializeWGL_I3D()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_I3D_digital_video_control ******

	isWGL_I3D_digital_video_control = isWExtensionSupported("WGL_I3D_digital_video_control");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isWGL_I3D_digital_video_control ) // || isSEDEnable()
	{
		wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) getExtensionPtr( "wglGetDigitalVideoParametersI3D" );
		if ( wglGetDigitalVideoParametersI3D != 0 )	++localInitializedProcCount;

		wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) getExtensionPtr( "wglSetDigitalVideoParametersI3D" );
		if ( wglSetDigitalVideoParametersI3D != 0 )	++localInitializedProcCount;

	} // if ( isWGL_I3D_digital_video_control )

	if ( isWGL_I3D_digital_video_control )
	{
		std::stringstream strStream;
		strStream << "WGL_I3D_digital_video_control                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_I3D_digital_video_control                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_I3D_digital_video_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_I3D_digital_video_control                     : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_I3D_gamma ******

	isWGL_I3D_gamma = isWExtensionSupported("WGL_I3D_gamma");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isWGL_I3D_gamma ) // || isSEDEnable()
	{
		wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC) getExtensionPtr( "wglGetGammaTableI3D" );
		if ( wglGetGammaTableI3D != 0 )	++localInitializedProcCount;

		wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) getExtensionPtr( "wglGetGammaTableParametersI3D" );
		if ( wglGetGammaTableParametersI3D != 0 )	++localInitializedProcCount;

		wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC) getExtensionPtr( "wglSetGammaTableI3D" );
		if ( wglSetGammaTableI3D != 0 )	++localInitializedProcCount;

		wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) getExtensionPtr( "wglSetGammaTableParametersI3D" );
		if ( wglSetGammaTableParametersI3D != 0 )	++localInitializedProcCount;

	} // if ( isWGL_I3D_gamma )

	if ( isWGL_I3D_gamma )
	{
		std::stringstream strStream;
		strStream << "WGL_I3D_gamma                                     : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_I3D_gamma                                     : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_I3D_gamma") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_I3D_gamma                                     : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_I3D_genlock ******

	isWGL_I3D_genlock = isWExtensionSupported("WGL_I3D_genlock");

	localSupportedProcCount		= 12;
	localInitializedProcCount	= 0;

	if ( isWGL_I3D_genlock ) // || isSEDEnable()
	{
		wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC) getExtensionPtr( "wglDisableGenlockI3D" );
		if ( wglDisableGenlockI3D != 0 )	++localInitializedProcCount;

		wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC) getExtensionPtr( "wglEnableGenlockI3D" );
		if ( wglEnableGenlockI3D != 0 )	++localInitializedProcCount;

		wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC) getExtensionPtr( "wglGenlockSampleRateI3D" );
		if ( wglGenlockSampleRateI3D != 0 )	++localInitializedProcCount;

		wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC) getExtensionPtr( "wglGenlockSourceDelayI3D" );
		if ( wglGenlockSourceDelayI3D != 0 )	++localInitializedProcCount;

		wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC) getExtensionPtr( "wglGenlockSourceEdgeI3D" );
		if ( wglGenlockSourceEdgeI3D != 0 )	++localInitializedProcCount;

		wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC) getExtensionPtr( "wglGenlockSourceI3D" );
		if ( wglGenlockSourceI3D != 0 )	++localInitializedProcCount;

		wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC) getExtensionPtr( "wglGetGenlockSampleRateI3D" );
		if ( wglGetGenlockSampleRateI3D != 0 )	++localInitializedProcCount;

		wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) getExtensionPtr( "wglGetGenlockSourceDelayI3D" );
		if ( wglGetGenlockSourceDelayI3D != 0 )	++localInitializedProcCount;

		wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) getExtensionPtr( "wglGetGenlockSourceEdgeI3D" );
		if ( wglGetGenlockSourceEdgeI3D != 0 )	++localInitializedProcCount;

		wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC) getExtensionPtr( "wglGetGenlockSourceI3D" );
		if ( wglGetGenlockSourceI3D != 0 )	++localInitializedProcCount;

		wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC) getExtensionPtr( "wglIsEnabledGenlockI3D" );
		if ( wglIsEnabledGenlockI3D != 0 )	++localInitializedProcCount;

		wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) getExtensionPtr( "wglQueryGenlockMaxSourceDelayI3D" );
		if ( wglQueryGenlockMaxSourceDelayI3D != 0 )	++localInitializedProcCount;

	} // if ( isWGL_I3D_genlock )

	if ( isWGL_I3D_genlock )
	{
		std::stringstream strStream;
		strStream << "WGL_I3D_genlock                                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_I3D_genlock                                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_I3D_genlock") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_I3D_genlock                                   : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_I3D_image_buffer ******

	isWGL_I3D_image_buffer = isWExtensionSupported("WGL_I3D_image_buffer");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isWGL_I3D_image_buffer ) // || isSEDEnable()
	{
		wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) getExtensionPtr( "wglAssociateImageBufferEventsI3D" );
		if ( wglAssociateImageBufferEventsI3D != 0 )	++localInitializedProcCount;

		wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC) getExtensionPtr( "wglCreateImageBufferI3D" );
		if ( wglCreateImageBufferI3D != 0 )	++localInitializedProcCount;

		wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC) getExtensionPtr( "wglDestroyImageBufferI3D" );
		if ( wglDestroyImageBufferI3D != 0 )	++localInitializedProcCount;

		wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) getExtensionPtr( "wglReleaseImageBufferEventsI3D" );
		if ( wglReleaseImageBufferEventsI3D != 0 )	++localInitializedProcCount;

	} // if ( isWGL_I3D_image_buffer )

	if ( isWGL_I3D_image_buffer )
	{
		std::stringstream strStream;
		strStream << "WGL_I3D_image_buffer                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_I3D_image_buffer                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_I3D_image_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_I3D_image_buffer                              : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_I3D_swap_frame_lock ******

	isWGL_I3D_swap_frame_lock = isWExtensionSupported("WGL_I3D_swap_frame_lock");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isWGL_I3D_swap_frame_lock ) // || isSEDEnable()
	{
		wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC) getExtensionPtr( "wglDisableFrameLockI3D" );
		if ( wglDisableFrameLockI3D != 0 )	++localInitializedProcCount;

		wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC) getExtensionPtr( "wglEnableFrameLockI3D" );
		if ( wglEnableFrameLockI3D != 0 )	++localInitializedProcCount;

		wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC) getExtensionPtr( "wglIsEnabledFrameLockI3D" );
		if ( wglIsEnabledFrameLockI3D != 0 )	++localInitializedProcCount;

		wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC) getExtensionPtr( "wglQueryFrameLockMasterI3D" );
		if ( wglQueryFrameLockMasterI3D != 0 )	++localInitializedProcCount;

	} // if ( isWGL_I3D_swap_frame_lock )

	if ( isWGL_I3D_swap_frame_lock )
	{
		std::stringstream strStream;
		strStream << "WGL_I3D_swap_frame_lock                           : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_I3D_swap_frame_lock                           : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_I3D_swap_frame_lock") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_I3D_swap_frame_lock                           : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_I3D_swap_frame_usage ******

	isWGL_I3D_swap_frame_usage = isWExtensionSupported("WGL_I3D_swap_frame_usage");

	localSupportedProcCount		= 4;
	localInitializedProcCount	= 0;

	if ( isWGL_I3D_swap_frame_usage ) // || isSEDEnable()
	{
		wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC) getExtensionPtr( "wglBeginFrameTrackingI3D" );
		if ( wglBeginFrameTrackingI3D != 0 )	++localInitializedProcCount;

		wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC) getExtensionPtr( "wglEndFrameTrackingI3D" );
		if ( wglEndFrameTrackingI3D != 0 )	++localInitializedProcCount;

		wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC) getExtensionPtr( "wglGetFrameUsageI3D" );
		if ( wglGetFrameUsageI3D != 0 )	++localInitializedProcCount;

		wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC) getExtensionPtr( "wglQueryFrameTrackingI3D" );
		if ( wglQueryFrameTrackingI3D != 0 )	++localInitializedProcCount;

	} // if ( isWGL_I3D_swap_frame_usage )

	if ( isWGL_I3D_swap_frame_usage )
	{
		std::stringstream strStream;
		strStream << "WGL_I3D_swap_frame_usage                          : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_I3D_swap_frame_usage                          : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_I3D_swap_frame_usage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_I3D_swap_frame_usage                          : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_I3D_swap_frame_usage()


void OpenGLExtensionsGen::initializeWGL_NV()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_NV_DX_interop ******

	isWGL_NV_DX_interop = isWExtensionSupported("WGL_NV_DX_interop");

	localSupportedProcCount		= 8;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_DX_interop ) // || isSEDEnable()
	{
		wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC) getExtensionPtr( "wglDXCloseDeviceNV" );
		if ( wglDXCloseDeviceNV != 0 )	++localInitializedProcCount;

		wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC) getExtensionPtr( "wglDXLockObjectsNV" );
		if ( wglDXLockObjectsNV != 0 )	++localInitializedProcCount;

		wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC) getExtensionPtr( "wglDXObjectAccessNV" );
		if ( wglDXObjectAccessNV != 0 )	++localInitializedProcCount;

		wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC) getExtensionPtr( "wglDXOpenDeviceNV" );
		if ( wglDXOpenDeviceNV != 0 )	++localInitializedProcCount;

		wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC) getExtensionPtr( "wglDXRegisterObjectNV" );
		if ( wglDXRegisterObjectNV != 0 )	++localInitializedProcCount;

		wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC) getExtensionPtr( "wglDXSetResourceShareHandleNV" );
		if ( wglDXSetResourceShareHandleNV != 0 )	++localInitializedProcCount;

		wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC) getExtensionPtr( "wglDXUnlockObjectsNV" );
		if ( wglDXUnlockObjectsNV != 0 )	++localInitializedProcCount;

		wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC) getExtensionPtr( "wglDXUnregisterObjectNV" );
		if ( wglDXUnregisterObjectNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_DX_interop )

	if ( isWGL_NV_DX_interop )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_DX_interop                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_DX_interop                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_DX_interop") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_DX_interop                                 : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_DX_interop2 ******

	isWGL_NV_DX_interop2 = isWExtensionSupported("WGL_NV_DX_interop2");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_DX_interop2 )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_DX_interop2                                : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_DX_interop2                                : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_DX_interop2") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_DX_interop2                                : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_copy_image ******

	isWGL_NV_copy_image = isWExtensionSupported("WGL_NV_copy_image");

	localSupportedProcCount		= 1;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_copy_image ) // || isSEDEnable()
	{
		wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC) getExtensionPtr( "wglCopyImageSubDataNV" );
		if ( wglCopyImageSubDataNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_copy_image )

	if ( isWGL_NV_copy_image )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_copy_image                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_copy_image                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_copy_image") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_copy_image                                 : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_float_buffer ******

	isWGL_NV_float_buffer = isWExtensionSupported("WGL_NV_float_buffer");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_float_buffer )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_float_buffer                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_float_buffer                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_float_buffer") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_float_buffer                               : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_gpu_affinity ******

	isWGL_NV_gpu_affinity = isWExtensionSupported("WGL_NV_gpu_affinity");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_gpu_affinity ) // || isSEDEnable()
	{
		wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC) getExtensionPtr( "wglCreateAffinityDCNV" );
		if ( wglCreateAffinityDCNV != 0 )	++localInitializedProcCount;

		wglDeleteDCNV = (PFNWGLDELETEDCNVPROC) getExtensionPtr( "wglDeleteDCNV" );
		if ( wglDeleteDCNV != 0 )	++localInitializedProcCount;

		wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC) getExtensionPtr( "wglEnumGpuDevicesNV" );
		if ( wglEnumGpuDevicesNV != 0 )	++localInitializedProcCount;

		wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) getExtensionPtr( "wglEnumGpusFromAffinityDCNV" );
		if ( wglEnumGpusFromAffinityDCNV != 0 )	++localInitializedProcCount;

		wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC) getExtensionPtr( "wglEnumGpusNV" );
		if ( wglEnumGpusNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_gpu_affinity )

	if ( isWGL_NV_gpu_affinity )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_gpu_affinity                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_gpu_affinity                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_gpu_affinity") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_gpu_affinity                               : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_multisample_coverage ******

	isWGL_NV_multisample_coverage = isWExtensionSupported("WGL_NV_multisample_coverage");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_multisample_coverage )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_multisample_coverage                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_multisample_coverage                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_multisample_coverage") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_multisample_coverage                       : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_present_video ******

	isWGL_NV_present_video = isWExtensionSupported("WGL_NV_present_video");

	localSupportedProcCount		= 3;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_present_video ) // || isSEDEnable()
	{
		wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC) getExtensionPtr( "wglBindVideoDeviceNV" );
		if ( wglBindVideoDeviceNV != 0 )	++localInitializedProcCount;

		wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC) getExtensionPtr( "wglEnumerateVideoDevicesNV" );
		if ( wglEnumerateVideoDevicesNV != 0 )	++localInitializedProcCount;

		wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC) getExtensionPtr( "wglQueryCurrentContextNV" );
		if ( wglQueryCurrentContextNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_present_video )

	if ( isWGL_NV_present_video )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_present_video                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_present_video                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_present_video") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_present_video                              : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_render_depth_texture ******

	isWGL_NV_render_depth_texture = isWExtensionSupported("WGL_NV_render_depth_texture");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_render_depth_texture )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_render_depth_texture                       : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_render_depth_texture                       : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_render_depth_texture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_render_depth_texture                       : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_render_texture_rectangle ******

	isWGL_NV_render_texture_rectangle = isWExtensionSupported("WGL_NV_render_texture_rectangle");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_render_texture_rectangle )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_render_texture_rectangle                   : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_render_texture_rectangle                   : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_render_texture_rectangle") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_render_texture_rectangle                   : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_swap_group ******

	isWGL_NV_swap_group = isWExtensionSupported("WGL_NV_swap_group");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_swap_group ) // || isSEDEnable()
	{
		wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC) getExtensionPtr( "wglBindSwapBarrierNV" );
		if ( wglBindSwapBarrierNV != 0 )	++localInitializedProcCount;

		wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC) getExtensionPtr( "wglJoinSwapGroupNV" );
		if ( wglJoinSwapGroupNV != 0 )	++localInitializedProcCount;

		wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC) getExtensionPtr( "wglQueryFrameCountNV" );
		if ( wglQueryFrameCountNV != 0 )	++localInitializedProcCount;

		wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC) getExtensionPtr( "wglQueryMaxSwapGroupsNV" );
		if ( wglQueryMaxSwapGroupsNV != 0 )	++localInitializedProcCount;

		wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC) getExtensionPtr( "wglQuerySwapGroupNV" );
		if ( wglQuerySwapGroupNV != 0 )	++localInitializedProcCount;

		wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC) getExtensionPtr( "wglResetFrameCountNV" );
		if ( wglResetFrameCountNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_swap_group )

	if ( isWGL_NV_swap_group )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_swap_group                                 : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_swap_group                                 : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_swap_group") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_swap_group                                 : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_vertex_array_range ******

	isWGL_NV_vertex_array_range = isWExtensionSupported("WGL_NV_vertex_array_range");

	localSupportedProcCount		= 2;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_vertex_array_range ) // || isSEDEnable()
	{
		wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC) getExtensionPtr( "wglAllocateMemoryNV" );
		if ( wglAllocateMemoryNV != 0 )	++localInitializedProcCount;

		wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC) getExtensionPtr( "wglFreeMemoryNV" );
		if ( wglFreeMemoryNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_vertex_array_range )

	if ( isWGL_NV_vertex_array_range )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_vertex_array_range                         : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_vertex_array_range                         : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_vertex_array_range") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_vertex_array_range                         : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_video_capture ******

	isWGL_NV_video_capture = isWExtensionSupported("WGL_NV_video_capture");

	localSupportedProcCount		= 5;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_video_capture ) // || isSEDEnable()
	{
		wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "wglBindVideoCaptureDeviceNV" );
		if ( wglBindVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

		wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) getExtensionPtr( "wglEnumerateVideoCaptureDevicesNV" );
		if ( wglEnumerateVideoCaptureDevicesNV != 0 )	++localInitializedProcCount;

		wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "wglLockVideoCaptureDeviceNV" );
		if ( wglLockVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

		wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "wglQueryVideoCaptureDeviceNV" );
		if ( wglQueryVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

		wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) getExtensionPtr( "wglReleaseVideoCaptureDeviceNV" );
		if ( wglReleaseVideoCaptureDeviceNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_video_capture )

	if ( isWGL_NV_video_capture )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_video_capture                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_video_capture                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_video_capture") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_video_capture                              : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_video_out ******

	isWGL_NV_video_out = isWExtensionSupported("WGL_NV_video_out");

	localSupportedProcCount		= 0;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_video_out )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_video_out                                  : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_video_out                                  : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_video_out") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_video_out                                  : not detected." );
	}


#endif // ifdef WIN32

#ifdef WIN32

	// ****** WGL_NV_video_output ******

	isWGL_NV_video_output = isWExtensionSupported("WGL_NV_video_output");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isWGL_NV_video_output ) // || isSEDEnable()
	{
		wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC) getExtensionPtr( "wglBindVideoImageNV" );
		if ( wglBindVideoImageNV != 0 )	++localInitializedProcCount;

		wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC) getExtensionPtr( "wglGetVideoDeviceNV" );
		if ( wglGetVideoDeviceNV != 0 )	++localInitializedProcCount;

		wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC) getExtensionPtr( "wglGetVideoInfoNV" );
		if ( wglGetVideoInfoNV != 0 )	++localInitializedProcCount;

		wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC) getExtensionPtr( "wglReleaseVideoDeviceNV" );
		if ( wglReleaseVideoDeviceNV != 0 )	++localInitializedProcCount;

		wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC) getExtensionPtr( "wglReleaseVideoImageNV" );
		if ( wglReleaseVideoImageNV != 0 )	++localInitializedProcCount;

		wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC) getExtensionPtr( "wglSendPbufferToVideoNV" );
		if ( wglSendPbufferToVideoNV != 0 )	++localInitializedProcCount;

	} // if ( isWGL_NV_video_output )

	if ( isWGL_NV_video_output )
	{
		std::stringstream strStream;
		strStream << "WGL_NV_video_output                               : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_NV_video_output                               : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_NV_video_output") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_NV_video_output                               : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_NV_video_output()


void OpenGLExtensionsGen::initializeWGL_OML()
{
	int	localSupportedProcCount 	= 0;
	int	localInitializedProcCount	= 0;

#ifdef WIN32

	// ****** WGL_OML_sync_control ******

	isWGL_OML_sync_control = isWExtensionSupported("WGL_OML_sync_control");

	localSupportedProcCount		= 6;
	localInitializedProcCount	= 0;

	if ( isWGL_OML_sync_control ) // || isSEDEnable()
	{
		wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC) getExtensionPtr( "wglGetMscRateOML" );
		if ( wglGetMscRateOML != 0 )	++localInitializedProcCount;

		wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC) getExtensionPtr( "wglGetSyncValuesOML" );
		if ( wglGetSyncValuesOML != 0 )	++localInitializedProcCount;

		wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC) getExtensionPtr( "wglSwapBuffersMscOML" );
		if ( wglSwapBuffersMscOML != 0 )	++localInitializedProcCount;

		wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) getExtensionPtr( "wglSwapLayerBuffersMscOML" );
		if ( wglSwapLayerBuffersMscOML != 0 )	++localInitializedProcCount;

		wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC) getExtensionPtr( "wglWaitForMscOML" );
		if ( wglWaitForMscOML != 0 )	++localInitializedProcCount;

		wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC) getExtensionPtr( "wglWaitForSbcOML" );
		if ( wglWaitForSbcOML != 0 )	++localInitializedProcCount;

	} // if ( isWGL_OML_sync_control )

	if ( isWGL_OML_sync_control )
	{
		std::stringstream strStream;
		strStream << "WGL_OML_sync_control                              : detected, " << localInitializedProcCount << "/" << localSupportedProcCount << " procedures initialized." << std::ends << std::endl;
		log( strStream.str() );

		if ( localInitializedProcCount < localSupportedProcCount  )
		{
			std::stringstream strStream;
			strStream << "WGL_OML_sync_control                              : " << localSupportedProcCount-localInitializedProcCount;
			strStream << " missing entry point(s), is there a bug in the driver !!!" << std::ends << std::endl;
			log( strStream.str() );
		}
		else
		{
			m_initializedExtensions.push_back( std::string("WGL_OML_sync_control") );
			++m_initializedExtensionCount;
			m_initializedProcCount += localInitializedProcCount;
		}
	}
	else
	{
		logEndl( "WGL_OML_sync_control                              : not detected." );
	}


#endif // ifdef WIN32

} // initializeWGL_OML_sync_control()




} // namespace gle
